feat(init): support org/project positional to pin org and project name

Replace the directory positional with an org/project target using
parseOrgProjectArg. Directory is now a --directory/-d flag.

Supported forms:
  sentry init                    — auto-detect everything
  sentry init acme               — explicit org
  sentry init acme/my-app        — explicit org + project name
  sentry init --directory ./dir  — specify project directory

When org is provided explicitly, createSentryProject skips interactive
org resolution. When project name is provided, it overrides the
wizard-detected name.

Author: MathurAditya724

src/commands/init.ts

@@ -4,11 +4,19 @@
  * Initialize Sentry in a project using the remote wizard workflow.
  * Communicates with the Mastra API via suspend/resume to perform
  * local filesystem operations and interactive prompts.
+ *
+ * Supports org/project positional syntax to pin org and/or project name:
+ *   sentry init                    — auto-detect everything
+ *   sentry init acme               — explicit org, wizard picks project name
+ *   sentry init acme/my-app        — explicit org + project name override
+ *   sentry init --directory ./dir  — specify project directory
  */
 
 import path from "node:path";
 import type { SentryContext } from "../context.js";
+import { parseOrgProjectArg } from "../lib/arg-parsing.js";
 import { buildCommand } from "../lib/command.js";
+import { ContextError } from "../lib/errors.js";
 import { runWizard } from "../lib/init/wizard-runner.js";
 
 const FEATURE_DELIMITER = /[,+ ]+/;
@@ -18,22 +26,31 @@ type InitFlags = {
   readonly "dry-run": boolean;
   readonly features?: string[];
   readonly team?: string;
+  readonly directory?: string;
 };
 
 export const initCommand = buildCommand<InitFlags, [string?], SentryContext>({
   docs: {
     brief: "Initialize Sentry in your project",
     fullDescription:
       "Runs the Sentry setup wizard to detect your project's framework, " +
-      "install the SDK, and configure Sentry.",
+      "install the SDK, and configure Sentry.\n\n" +
+      "The target supports org/project syntax to specify context explicitly.\n" +
+      "If omitted, the org is auto-detected from config defaults.\n\n" +
+      "Examples:\n" +
+      "  sentry init\n" +
+      "  sentry init acme\n" +
+      "  sentry init acme/my-app\n" +
+      "  sentry init acme/my-app --directory ./my-project\n" +
+      "  sentry init --directory ./my-project",
   },
   parameters: {
     positional: {
       kind: "tuple",
       parameters: [
         {
-          placeholder: "directory",
-          brief: "Project directory (default: current directory)",
+          placeholder: "target",
+          brief: "<org>/<project>, <org>, or omit for auto-detect",
           parse: String,
           optional: true,
         },
@@ -63,25 +80,67 @@ export const initCommand = buildCommand<InitFlags, [string?], SentryContext>({
         brief: "Team slug to create the project under",
         optional: true,
       },
+      directory: {
+        kind: "parsed",
+        parse: String,
+        brief: "Project directory (default: current directory)",
+        optional: true,
+      },
     },
     aliases: {
       y: "yes",
       t: "team",
+      d: "directory",
     },
   },
-  async *func(this: SentryContext, flags: InitFlags, directory?: string) {
-    const targetDir = directory ? path.resolve(this.cwd, directory) : this.cwd;
+  async *func(this: SentryContext, flags: InitFlags, targetArg?: string) {
+    const targetDir = flags.directory
+      ? path.resolve(this.cwd, flags.directory)
+      : this.cwd;
+
     const featuresList = flags.features
       ?.flatMap((f) => f.split(FEATURE_DELIMITER))
       .map((f) => f.trim())
       .filter(Boolean);
 
+    // Parse the target arg to extract org and/or project
+    const parsed = parseOrgProjectArg(targetArg);
+
+    let explicitOrg: string | undefined;
+    let explicitProject: string | undefined;
+
+    switch (parsed.type) {
+      case "explicit":
+        explicitOrg = parsed.org;
+        explicitProject = parsed.project;
+        break;
+      case "org-all":
+        // "acme/" or bare "acme" — org only, no project name override
+        explicitOrg = parsed.org;
+        break;
+      case "project-search":
+        // Bare string without "/" — could be an org slug or a project name.
+        // Treat it as an org slug since `sentry init <org>` is the primary use case.
+        // Users who want to override the project name should use org/project syntax.
+        explicitOrg = parsed.projectSlug;
+        break;
+      case "auto-detect":
+        // No target provided — auto-detect everything
+        break;
+      default: {
+        const _exhaustive: never = parsed;
+        throw new ContextError("Target", String(_exhaustive));
+      }
+    }
+
     await runWizard({
       directory: targetDir,
       yes: flags.yes,
       dryRun: flags["dry-run"],
       features: featuresList,
       team: flags.team,
+      org: explicitOrg,
+      project: explicitProject,
     });
   },
 });

src/lib/init/local-ops.ts

@@ -706,7 +706,9 @@ async function createSentryProject(
   payload: CreateSentryProjectPayload,
   options: WizardOptions
 ): Promise<LocalOpResult> {
-  const { name, platform } = payload.params;
+  // Use CLI-provided project name if available, otherwise use wizard-detected name
+  const name = options.project ?? payload.params.name;
+  const { platform } = payload.params;
   const slug = slugify(name);
   if (!slug) {
     return {
@@ -720,7 +722,7 @@ async function createSentryProject(
     return {
       ok: true,
       data: {
-        orgSlug: "(dry-run)",
+        orgSlug: options.org ?? "(dry-run)",
         projectSlug: slug,
         projectId: "(dry-run)",
         dsn: "(dry-run)",
@@ -730,12 +732,17 @@ async function createSentryProject(
   }
 
   try {
-    // 1. Resolve org
-    const orgResult = await resolveOrgSlug(payload.cwd, options.yes);
-    if (typeof orgResult !== "string") {
-      return orgResult;
+    // 1. Resolve org — skip interactive resolution if explicitly provided via CLI arg
+    let orgSlug: string;
+    if (options.org) {
+      orgSlug = options.org;
+    } else {
+      const orgResult = await resolveOrgSlug(payload.cwd, options.yes);
+      if (typeof orgResult !== "string") {
+        return orgResult;
+      }
+      orgSlug = orgResult;
     }
-    const orgSlug = orgResult;
 
     // 2. Resolve or create team
     const team = await resolveOrCreateTeam(orgSlug, {

src/lib/init/types.ts

@@ -11,6 +11,10 @@ export type WizardOptions = {
   features?: string[];
   /** Explicit team slug to create the project under. Skips team resolution. */
   team?: string;
+  /** Explicit org slug from CLI arg (e.g., "acme" from "acme/my-app"). Skips interactive org selection. */
+  org?: string;
+  /** Explicit project name from CLI arg (e.g., "my-app" from "acme/my-app"). Overrides wizard-detected name. */
+  project?: string;
 };
 
 // Local-op suspend payloads

test/commands/init.test.ts

@@ -15,15 +15,15 @@ import * as wizardRunner from "../../src/lib/init/wizard-runner.js";
 let capturedArgs: Record<string, unknown> | undefined;
 let runWizardSpy: ReturnType<typeof spyOn>;
 
-const func = (await initCommand.loader()) as (
+const func = (await initCommand.loader()) as unknown as (
   this: {
     cwd: string;
     stdout: { write: () => boolean };
     stderr: { write: () => boolean };
     stdin: typeof process.stdin;
   },
   flags: Record<string, unknown>,
-  directory?: string
+  target?: string
 ) => Promise<void>;
 
 function makeContext(cwd = "/projects/app") {
@@ -129,7 +129,7 @@ describe("init command func", () => {
   });
 
   describe("directory resolution", () => {
-    test("defaults to cwd when no directory provided", async () => {
+    test("defaults to cwd when no --directory flag provided", async () => {
       const ctx = makeContext("/projects/app");
       await func.call(ctx, {
         yes: true,
@@ -139,16 +139,13 @@ describe("init command func", () => {
       expect(capturedArgs?.directory).toBe("/projects/app");
     });
 
-    test("resolves relative directory against cwd", async () => {
+    test("resolves relative --directory flag against cwd", async () => {
       const ctx = makeContext("/projects/app");
-      await func.call(
-        ctx,
-        {
-          yes: true,
-          "dry-run": false,
-        },
-        "sub/dir"
-      );
+      await func.call(ctx, {
+        yes: true,
+        "dry-run": false,
+        directory: "sub/dir",
+      });
 
       expect(capturedArgs?.directory).toBe(
         path.resolve("/projects/app", "sub/dir")
@@ -168,4 +165,98 @@ describe("init command func", () => {
       expect(capturedArgs?.dryRun).toBe(true);
     });
   });
+
+  describe("org/project parsing", () => {
+    test("passes undefined org/project when no target provided", async () => {
+      const ctx = makeContext();
+      await func.call(ctx, {
+        yes: true,
+        "dry-run": false,
+      });
+
+      expect(capturedArgs?.org).toBeUndefined();
+      expect(capturedArgs?.project).toBeUndefined();
+    });
+
+    test("parses org/project from explicit target", async () => {
+      const ctx = makeContext();
+      await func.call(
+        ctx,
+        {
+          yes: true,
+          "dry-run": false,
+        },
+        "acme/my-app"
+      );
+
+      expect(capturedArgs?.org).toBe("acme");
+      expect(capturedArgs?.project).toBe("my-app");
+    });
+
+    test("parses bare string as org (no project override)", async () => {
+      const ctx = makeContext();
+      await func.call(
+        ctx,
+        {
+          yes: true,
+          "dry-run": false,
+        },
+        "acme"
+      );
+
+      expect(capturedArgs?.org).toBe("acme");
+      expect(capturedArgs?.project).toBeUndefined();
+    });
+
+    test("parses org/ as org-only (no project override)", async () => {
+      const ctx = makeContext();
+      await func.call(
+        ctx,
+        {
+          yes: true,
+          "dry-run": false,
+        },
+        "acme/"
+      );
+
+      expect(capturedArgs?.org).toBe("acme");
+      expect(capturedArgs?.project).toBeUndefined();
+    });
+
+    test("combines target with --directory flag", async () => {
+      const ctx = makeContext("/projects/app");
+      await func.call(
+        ctx,
+        {
+          yes: true,
+          "dry-run": false,
+          directory: "sub/dir",
+        },
+        "acme/my-app"
+      );
+
+      expect(capturedArgs?.org).toBe("acme");
+      expect(capturedArgs?.project).toBe("my-app");
+      expect(capturedArgs?.directory).toBe(
+        path.resolve("/projects/app", "sub/dir")
+      );
+    });
+
+    test("forwards team flag alongside org/project", async () => {
+      const ctx = makeContext();
+      await func.call(
+        ctx,
+        {
+          yes: true,
+          "dry-run": false,
+          team: "backend",
+        },
+        "acme/my-app"
+      );
+
+      expect(capturedArgs?.org).toBe("acme");
+      expect(capturedArgs?.project).toBe("my-app");
+      expect(capturedArgs?.team).toBe("backend");
+    });
+  });
 });