feat: add project delete command

Add `sentry project delete` subcommand for permanently deleting Sentry
projects via the API.

Safety measures:
- Requires explicit target (no auto-detect to prevent accidental deletion)
- Confirmation prompt with --yes/-y flag to skip
- Refuses to run in non-interactive mode without --yes
- Verifies project exists before prompting

Changes:
- src/commands/project/delete.ts: New command implementation
- src/commands/project/index.ts: Register delete in route map
- src/lib/api-client.ts: Add deleteProject() using @sentry/api SDK
- test/commands/project/delete.test.ts: Unit tests (8 tests)

Author: MathurAditya724

src/commands/project/delete.ts

@@ -0,0 +1,153 @@
+/**
+ * sentry project delete
+ *
+ * Permanently delete a Sentry project.
+ *
+ * ## Flow
+ *
+ * 1. Parse target arg → extract org/project (e.g., "acme/my-app" or "my-app")
+ * 2. Verify the project exists via `getProject` (also displays its name)
+ * 3. Prompt for confirmation (unless --yes is passed)
+ * 4. Call `deleteProject` API
+ * 5. Display result
+ *
+ * Safety measures:
+ * - No auto-detect mode: requires explicit target to prevent accidental deletion
+ * - Confirmation prompt with strict `confirmed !== true` check (Symbol(clack:cancel) gotcha)
+ * - Refuses to run in non-interactive mode without --yes flag
+ */
+
+import { isatty } from "node:tty";
+import type { SentryContext } from "../../context.js";
+import { deleteProject, getProject } from "../../lib/api-client.js";
+import {
+  ProjectSpecificationType,
+  parseOrgProjectArg,
+} from "../../lib/arg-parsing.js";
+import { buildCommand } from "../../lib/command.js";
+import { CliError, ContextError } from "../../lib/errors.js";
+import { logger } from "../../lib/logger.js";
+import { resolveProjectBySlug } from "../../lib/resolve-target.js";
+
+const log = logger.withTag("project.delete");
+
+/** Usage hint for error messages */
+const USAGE_HINT = "sentry project delete <org>/<project>";
+
+type DeleteFlags = {
+  readonly yes: boolean;
+  readonly json: boolean;
+  readonly fields?: string[];
+};
+
+export const deleteCommand = buildCommand({
+  docs: {
+    brief: "Delete a project",
+    fullDescription:
+      "Permanently delete a Sentry project. This action cannot be undone.\n\n" +
+      "Requires explicit target — auto-detection is disabled for safety.\n\n" +
+      "Examples:\n" +
+      "  sentry project delete acme-corp/my-app\n" +
+      "  sentry project delete my-app\n" +
+      "  sentry project delete acme-corp/my-app --yes",
+  },
+  output: "json",
+  parameters: {
+    positional: {
+      kind: "tuple",
+      parameters: [
+        {
+          placeholder: "org/project",
+          brief: "<org>/<project> or <project> (search across orgs)",
+          parse: String,
+        },
+      ],
+    },
+    flags: {
+      yes: {
+        kind: "boolean",
+        brief: "Skip confirmation prompt",
+        default: false,
+      },
+    },
+    aliases: { y: "yes" },
+  },
+  async func(this: SentryContext, flags: DeleteFlags, target: string) {
+    const { stdout } = this;
+    const parsed = parseOrgProjectArg(target);
+
+    let orgSlug: string;
+    let projectSlug: string;
+
+    switch (parsed.type) {
+      case ProjectSpecificationType.Explicit:
+        orgSlug = parsed.org;
+        projectSlug = parsed.project;
+        break;
+
+      case ProjectSpecificationType.ProjectSearch: {
+        const resolved = await resolveProjectBySlug(
+          parsed.projectSlug,
+          USAGE_HINT,
+          `sentry project delete <org>/${parsed.projectSlug}`
+        );
+        orgSlug = resolved.org;
+        projectSlug = resolved.project;
+        break;
+      }
+
+      case ProjectSpecificationType.OrgAll:
+        throw new ContextError(
+          "Specific project",
+          `${USAGE_HINT}\n\n` +
+            "Specify the full org/project target, not just the organization."
+        );
+
+      case ProjectSpecificationType.AutoDetect:
+        throw new ContextError("Project target", USAGE_HINT, [
+          "Auto-detection is disabled for delete — specify the target explicitly",
+        ]);
+
+      default: {
+        const _exhaustive: never = parsed;
+        throw new ContextError("Project", String(_exhaustive));
+      }
+    }
+
+    // Verify project exists before prompting — also used to display the project name
+    const project = await getProject(orgSlug, projectSlug);
+
+    // Confirmation gate
+    if (!flags.yes) {
+      if (!isatty(0)) {
+        throw new CliError(
+          `Refusing to delete '${orgSlug}/${project.slug}' in non-interactive mode. Use --yes to confirm.`
+        );
+      }
+
+      const confirmed = await log.prompt(
+        `Delete project '${project.name}' (${orgSlug}/${project.slug})? This cannot be undone.`,
+        { type: "confirm", initial: false }
+      );
+
+      // consola prompt returns Symbol(clack:cancel) on Ctrl+C — a truthy value.
+      // Strictly check for `true` to avoid deleting on cancel.
+      if (confirmed !== true) {
+        stdout.write("Cancelled.\n");
+        return;
+      }
+    }
+
+    await deleteProject(orgSlug, project.slug);
+
+    if (flags.json) {
+      stdout.write(
+        `${JSON.stringify({ deleted: true, org: orgSlug, project: project.slug })}\n`
+      );
+    } else {
+      stdout.write(
+        `Deleted project '${project.name}' (${orgSlug}/${project.slug}).\n`
+      );
+    }
+  },
+});

src/commands/project/index.ts

@@ -1,11 +1,13 @@
 import { buildRouteMap } from "@stricli/core";
 import { createCommand } from "./create.js";
+import { deleteCommand } from "./delete.js";
 import { listCommand } from "./list.js";
 import { viewCommand } from "./view.js";
 
 export const projectRoute = buildRouteMap({
   routes: {
     create: createCommand,
+    delete: deleteCommand,
     list: listCommand,
     view: viewCommand,
   },

src/lib/api-client.ts

@@ -13,6 +13,7 @@ import {
   addAnOrganizationMemberToATeam,
   createANewProject,
   createANewTeam,
+  deleteAProject,
   listAnOrganization_sIssues,
   listAnOrganization_sProjects,
   listAnOrganization_sRepositories,
@@ -719,6 +720,30 @@ export async function createProject(
   return data as unknown as SentryProject;
 }
 
+/**
+ * Delete a project from an organization.
+ *
+ * Sends a DELETE request to the Sentry API. Returns 204 No Content on success.
+ *
+ * @param orgSlug - The organization slug
+ * @param projectSlug - The project slug to delete
+ * @throws {ApiError} 403 if the user lacks permission, 404 if the project doesn't exist
+ */
+export async function deleteProject(
+  orgSlug: string,
+  projectSlug: string
+): Promise<void> {
+  const config = await getOrgSdkConfig(orgSlug);
+  const result = await deleteAProject({
+    ...config,
+    path: {
+      organization_id_or_slug: orgSlug,
+      project_id_or_slug: projectSlug,
+    },
+  });
+  unwrapResult(result, "Failed to delete project");
+}
+
 /**
  * Create a new team in an organization and add the current user as a member.
  *

test/commands/project/delete.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Project Delete Command Tests
+ *
+ * Tests for the project delete command in src/commands/project/delete.ts.
+ * Uses spyOn to mock api-client and resolve-target to test
+ * the func() body without real HTTP calls or database access.
+ */
+
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from "bun:test";
+import { deleteCommand } from "../../../src/commands/project/delete.js";
+// biome-ignore lint/performance/noNamespaceImport: needed for spyOn mocking
+import * as apiClient from "../../../src/lib/api-client.js";
+import { ApiError, ContextError } from "../../../src/lib/errors.js";
+// biome-ignore lint/performance/noNamespaceImport: needed for spyOn mocking
+import * as resolveTarget from "../../../src/lib/resolve-target.js";
+import type { SentryProject } from "../../../src/types/index.js";
+
+const sampleProject: SentryProject = {
+  id: "999",
+  slug: "my-app",
+  name: "My App",
+  platform: "python",
+  dateCreated: "2026-02-12T10:00:00Z",
+};
+
+function createMockContext() {
+  const stdoutWrite = mock(() => true);
+  const stderrWrite = mock(() => true);
+  return {
+    context: {
+      stdout: { write: stdoutWrite },
+      stderr: { write: stderrWrite },
+      cwd: "/tmp",
+      setContext: mock(() => {
+        // no-op for test
+      }),
+    },
+    stdoutWrite,
+    stderrWrite,
+  };
+}
+
+describe("project delete", () => {
+  let getProjectSpy: ReturnType<typeof spyOn>;
+  let deleteProjectSpy: ReturnType<typeof spyOn>;
+  let resolveProjectBySlugSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    getProjectSpy = spyOn(apiClient, "getProject");
+    deleteProjectSpy = spyOn(apiClient, "deleteProject");
+    resolveProjectBySlugSpy = spyOn(resolveTarget, "resolveProjectBySlug");
+
+    // Default mocks
+    getProjectSpy.mockResolvedValue(sampleProject);
+    deleteProjectSpy.mockResolvedValue(undefined);
+    resolveProjectBySlugSpy.mockResolvedValue({
+      org: "acme-corp",
+      project: "my-app",
+    });
+  });
+
+  afterEach(() => {
+    getProjectSpy.mockRestore();
+    deleteProjectSpy.mockRestore();
+    resolveProjectBySlugSpy.mockRestore();
+  });
+
+  test("deletes project with explicit org/project and --yes", async () => {
+    const { context, stdoutWrite } = createMockContext();
+    const func = await deleteCommand.loader();
+    await func.call(context, { yes: true, json: false }, "acme-corp/my-app");
+
+    expect(getProjectSpy).toHaveBeenCalledWith("acme-corp", "my-app");
+    expect(deleteProjectSpy).toHaveBeenCalledWith("acme-corp", "my-app");
+
+    const output = stdoutWrite.mock.calls.map((c) => c[0]).join("");
+    expect(output).toContain("Deleted project 'My App'");
+    expect(output).toContain("acme-corp/my-app");
+  });
+
+  test("deletes project with bare slug and --yes", async () => {
+    const { context } = createMockContext();
+    const func = await deleteCommand.loader();
+    await func.call(context, { yes: true, json: false }, "my-app");
+
+    expect(resolveProjectBySlugSpy).toHaveBeenCalledWith(
+      "my-app",
+      "sentry project delete <org>/<project>",
+      "sentry project delete <org>/my-app"
+    );
+    expect(deleteProjectSpy).toHaveBeenCalledWith("acme-corp", "my-app");
+  });
+
+  test("errors when only org is provided (org-all)", async () => {
+    const { context } = createMockContext();
+    const func = await deleteCommand.loader();
+
+    await expect(
+      func.call(context, { yes: true, json: false }, "acme-corp/")
+    ).rejects.toThrow(ContextError);
+
+    expect(deleteProjectSpy).not.toHaveBeenCalled();
+  });
+
+  test("errors in non-interactive mode without --yes", async () => {
+    const { context } = createMockContext();
+    const func = await deleteCommand.loader();
+
+    // isatty(0) returns false in test environments (non-TTY)
+    await expect(
+      func.call(context, { yes: false, json: false }, "acme-corp/my-app")
+    ).rejects.toThrow("non-interactive mode");
+
+    expect(deleteProjectSpy).not.toHaveBeenCalled();
+  });
+
+  test("outputs JSON when --json flag is set", async () => {
+    const { context, stdoutWrite } = createMockContext();
+    const func = await deleteCommand.loader();
+    await func.call(context, { yes: true, json: true }, "acme-corp/my-app");
+
+    const output = stdoutWrite.mock.calls.map((c) => c[0]).join("");
+    const parsed = JSON.parse(output.trim());
+    expect(parsed).toEqual({
+      deleted: true,
+      org: "acme-corp",
+      project: "my-app",
+    });
+  });
+
+  test("propagates 404 from getProject", async () => {
+    getProjectSpy.mockRejectedValue(
+      new ApiError("Not found", 404, "Project not found")
+    );
+
+    const { context } = createMockContext();
+    const func = await deleteCommand.loader();
+
+    await expect(
+      func.call(context, { yes: true, json: false }, "acme-corp/my-app")
+    ).rejects.toThrow(ApiError);
+
+    expect(deleteProjectSpy).not.toHaveBeenCalled();
+  });
+
+  test("propagates 403 from deleteProject", async () => {
+    deleteProjectSpy.mockRejectedValue(
+      new ApiError("Forbidden", 403, "You do not have permission")
+    );
+
+    const { context } = createMockContext();
+    const func = await deleteCommand.loader();
+
+    await expect(
+      func.call(context, { yes: true, json: false }, "acme-corp/my-app")
+    ).rejects.toThrow(ApiError);
+  });
+
+  test("verifies project exists before attempting delete", async () => {
+    const { context } = createMockContext();
+    const func = await deleteCommand.loader();
+    await func.call(context, { yes: true, json: false }, "acme-corp/my-app");
+
+    // getProject must be called before deleteProject
+    const getProjectOrder = getProjectSpy.mock.invocationCallOrder[0];
+    const deleteProjectOrder = deleteProjectSpy.mock.invocationCallOrder[0];
+    expect(getProjectOrder).toBeLessThan(deleteProjectOrder ?? 0);
+  });
+});