@spekn/cli 1.0.0

package/dist/commands/marketplace-export.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMarketplaceExportCli = runMarketplaceExportCli;
+exports.main = main;
+exports.parseArgs = parseArgs;
+const client_1 = require("@trpc/client");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const credentials_store_1 = require("../auth/credentials-store");
+const export_1 = require("./export");
+const project_context_1 = require("../project-context");
+const structured_log_1 = require("../utils/structured-log");
+const defaultDeps = {
+    createClient: (apiUrl, organizationId, authToken) => (0, client_1.createTRPCProxyClient)({
+        links: [
+            (0, client_1.httpBatchLink)({
+                url: (0, export_1.normalizeTrpcUrl)(apiUrl),
+                headers: {
+                    'x-organization-id': organizationId,
+                    authorization: authToken ? `Bearer ${authToken}` : '',
+                },
+            }),
+        ],
+    }),
+    writeFile: (filePath, content) => {
+        fs.writeFileSync(filePath, content, 'utf-8');
+    },
+    mkdirSync: (dirPath) => {
+        fs.mkdirSync(dirPath, { recursive: true });
+    },
+    stdout: (content) => process.stdout.write(content),
+    stderr: (content) => process.stderr.write(content),
+    credentialsStore: new credentials_store_1.CredentialsStore(),
+};
+function printHelp(stderr) {
+    stderr(`
+marketplace export - Export Claude Code-compatible plugin marketplace to disk
+
+USAGE:
+  spekn marketplace export --project <uuid> [options]
+
+OPTIONS:
+  --project <uuid>            Project ID (optional if .spekn/context is present)
+  --output <dir>              Output directory (default: .)
+  --api-url <url>             API base URL (default: SPEKN_API_URL or https://app.spekn.com)
+  --marketplace-name <name>   Marketplace identifier (default: spekn-marketplace)
+  --owner-name <name>         Owner name (default: Spekn)
+  --help                      Show help
+`);
+}
+function parseArgs(args) {
+    let projectId = '';
+    let output = '.';
+    let apiUrl = process.env.SPEKN_API_URL || 'https://app.spekn.com';
+    let marketplaceName = 'spekn-marketplace';
+    let ownerName = 'Spekn';
+    for (let index = 0; index < args.length; index++) {
+        const arg = args[index];
+        if (arg === '--help' || arg === '-h') {
+            throw new Error('__HELP__');
+        }
+        if (arg === '--project' && args[index + 1]) {
+            projectId = args[++index];
+            continue;
+        }
+        if (arg.startsWith('--project=')) {
+            projectId = arg.slice('--project='.length);
+            continue;
+        }
+        if (arg === '--output' && args[index + 1]) {
+            output = args[++index];
+            continue;
+        }
+        if (arg.startsWith('--output=')) {
+            output = arg.slice('--output='.length);
+            continue;
+        }
+        if (arg === '--api-url' && args[index + 1]) {
+            apiUrl = args[++index];
+            continue;
+        }
+        if (arg.startsWith('--api-url=')) {
+            apiUrl = arg.slice('--api-url='.length);
+            continue;
+        }
+        if (arg === '--marketplace-name' && args[index + 1]) {
+            marketplaceName = args[++index];
+            continue;
+        }
+        if (arg.startsWith('--marketplace-name=')) {
+            marketplaceName = arg.slice('--marketplace-name='.length);
+            continue;
+        }
+        if (arg === '--owner-name' && args[index + 1]) {
+            ownerName = args[++index];
+            continue;
+        }
+        if (arg.startsWith('--owner-name=')) {
+            ownerName = arg.slice('--owner-name='.length);
+            continue;
+        }
+    }
+    return {
+        projectId,
+        output,
+        apiUrl,
+        marketplaceName,
+        ownerName,
+    };
+}
+async function runMarketplaceExportCli(args, deps = defaultDeps) {
+    try {
+        const options = parseArgs(args);
+        (0, structured_log_1.appendCliStructuredLog)({
+            source: 'cli.marketplace.export',
+            level: 'info',
+            message: 'Starting marketplace export',
+            details: { output: options.output, apiUrl: options.apiUrl, marketplaceName: options.marketplaceName },
+        });
+        const storedToken = await deps.credentialsStore.getValidToken();
+        const authToken = storedToken ?? process.env.SPEKN_AUTH_TOKEN;
+        const storedCreds = deps.credentialsStore.load();
+        const context = (0, project_context_1.resolveProjectContext)({
+            explicitProjectId: options.projectId,
+            repoPath: process.cwd(),
+            credentialsOrganizationId: storedCreds?.organizationId,
+            envOrganizationId: process.env.SPEKN_ORGANIZATION_ID,
+        });
+        const client = deps.createClient(options.apiUrl, context.organizationId, authToken ?? undefined);
+        const result = await client.marketplace.exportClaudeCodeCatalog.query({
+            marketplaceName: options.marketplaceName,
+            ownerName: options.ownerName,
+        });
+        const outputDir = path.resolve(process.cwd(), options.output);
+        // Write marketplace.json
+        const marketplaceDir = path.join(outputDir, '.claude-plugin');
+        deps.mkdirSync(marketplaceDir);
+        deps.writeFile(path.join(marketplaceDir, 'marketplace.json'), typeof result.json === 'string' ? result.json : JSON.stringify(result.json, null, 2));
+        // Write per-plugin manifests
+        for (const entry of result.entries) {
+            const pluginDir = path.join(outputDir, 'plugins', entry.name, '.claude-plugin');
+            deps.mkdirSync(pluginDir);
+            deps.writeFile(path.join(pluginDir, 'plugin.json'), JSON.stringify({
+                name: entry.name,
+                description: entry.description,
+                version: entry.version,
+                author: entry.author,
+            }, null, 2));
+        }
+        deps.stdout(`Exported ${result.pluginCount} plugins to ${outputDir}\n`);
+        (0, structured_log_1.appendCliStructuredLog)({
+            source: 'cli.marketplace.export',
+            level: 'info',
+            message: 'Marketplace export complete',
+            details: { outputDir, pluginCount: result.pluginCount },
+        });
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === '__HELP__') {
+            printHelp(deps.stderr);
+            return 0;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        deps.stderr(`Error: ${message}\n`);
+        (0, structured_log_1.appendCliStructuredLog)({
+            source: 'cli.marketplace.export',
+            level: 'error',
+            message,
+        });
+        return 1;
+    }
+}
+async function main() {
+    const exitCode = await runMarketplaceExportCli(process.argv.slice(2));
+    process.exit(exitCode);
+}
+if (require.main === module) {
+    void main();
+}

package/dist/commands/project-clean.d.ts

@@ -0,0 +1 @@
+export declare function runProjectDeleteCli(args: string[]): Promise<number>;

package/dist/commands/project-clean.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runProjectDeleteCli = runProjectDeleteCli;
+const client_1 = require("@trpc/client");
+const credentials_store_1 = require("../auth/credentials-store");
+const trpc_url_1 = require("../utils/trpc-url");
+/**
+ * Delete a project using the API. With the fixed foreign key constraints,
+ * the database will automatically cascade delete all related entities.
+ */
+async function deleteProject(projectId, apiUrl) {
+    const credentialsStore = new credentials_store_1.CredentialsStore();
+    const authToken = await credentialsStore.getValidToken();
+    if (!authToken) {
+        throw new Error("Not authenticated. Please run 'spekn auth login' first.");
+    }
+    const credentials = credentialsStore.load();
+    const organizationId = credentials?.organizationId ?? "";
+    const trpc = (0, client_1.createTRPCProxyClient)({
+        links: [
+            (0, client_1.httpBatchLink)({
+                url: (0, trpc_url_1.normalizeTrpcUrl)(apiUrl),
+                headers: {
+                    Authorization: `Bearer ${authToken}`,
+                    "x-organization-id": organizationId,
+                },
+            }),
+        ],
+    });
+    console.log(`Deleting project ${projectId}...`);
+    try {
+        // With the fixed foreign key constraints, this single call will
+        // automatically cascade delete all related entities
+        await trpc.project.delete.mutate({ id: projectId });
+        console.log(`✅ Project ${projectId} and all related entities have been successfully deleted.`);
+    }
+    catch (error) {
+        console.error("❌ Error deleting project:", error);
+        throw error;
+    }
+}
+function printHelp() {
+    console.log(`
+project delete - Delete a project and all its related entities
+
+USAGE:
+  spekn project delete <project-id> [options]
+
+ARGUMENTS:
+  <project-id>   Project ID to delete
+
+OPTIONS:
+  --api-url <url>   API URL (default: SPEKN_API_URL or https://app.spekn.com)
+  --force           Skip confirmation prompt
+  --help            Show this help message
+
+EXAMPLES:
+  spekn project delete 11111111-1111-4111-8111-111111111111
+  spekn project delete 11111111-1111-4111-8111-111111111111 --force
+`);
+}
+async function runProjectDeleteCli(args) {
+    // Parse arguments manually since we receive already-sliced args
+    let projectId;
+    let force = false;
+    let apiUrl = process.env.SPEKN_API_URL ?? "https://app.spekn.com";
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            printHelp();
+            return 0;
+        }
+        if (arg === "--force") {
+            force = true;
+            continue;
+        }
+        if (arg === "--api-url" && args[i + 1]) {
+            apiUrl = args[i + 1];
+            i++; // skip next arg
+            continue;
+        }
+        if (arg.startsWith("--api-url=")) {
+            apiUrl = arg.slice("--api-url=".length);
+            continue;
+        }
+        // Positional argument (project-id)
+        if (!projectId && !arg.startsWith("--")) {
+            projectId = arg;
+            continue;
+        }
+    }
+    // Validate required arguments
+    if (!projectId) {
+        console.error("Error: Missing required argument <project-id>");
+        printHelp();
+        return 1;
+    }
+    try {
+        // Add confirmation prompt unless --force is used
+        if (!force) {
+            // Note: In a real implementation, we would use a proper prompt library
+            // For now, we'll proceed without confirmation to keep it simple
+            console.log(`🚨 Warning: This will permanently delete project ${projectId} and all related data.`);
+            console.log(`📝 Related entities that will be deleted: git repositories, specifications, tasks, decisions, runs, verifications, notes, worktrees, merge requests`);
+            console.log(`🔥 This action cannot be undone.`);
+            // TODO: Add proper interactive confirmation
+            // const confirmed = await confirm("Are you sure you want to continue? (y/N)");
+            // if (!confirmed) {
+            //   console.log("💡 Deletion cancelled.");
+            //   return 0;
+            // }
+        }
+        await deleteProject(projectId, apiUrl);
+        return 0;
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+if (require.main === module) {
+    runProjectDeleteCli(process.argv.slice(2)).catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}

package/dist/commands/repo/common.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Shared utilities for repo register / repo sync CLI commands.
+ *
+ * Extracts common concerns: deps, auth, git metadata, tRPC client, and
+ * file discovery. ACP prompt-driven analysis utilities are used by
+ * `repo register`; `repo sync` runs ingestion drift analysis via API calls.
+ */
+import { CredentialsStore } from "../../auth/credentials-store";
+import { HelpRequestedError } from "../../utils/help-error";
+export interface Deps {
+    execGit: (args: string[]) => string;
+    stdout: (content: string) => void;
+    stderr: (content: string) => void;
+    credentialsStore: CredentialsStore;
+}
+export declare const defaultDeps: Deps;
+/** Fields common to both register and sync CLI options. */
+export interface CommonOptions {
+    projectId: string;
+    apiUrl: string;
+    analyze: boolean;
+    agent: string | null;
+    repoPath: string;
+    dryRun: boolean;
+    mcpUrl: string;
+    debug: boolean;
+    acpTimeoutMs?: number;
+}
+export interface DiscoveredFile {
+    relativePath: string;
+    absolutePath: string;
+    category: "governance" | "spec" | "decision" | "config" | "pdf";
+}
+export { HelpRequestedError };
+/**
+ * Parse flags shared by both register and sync. Returns consumed arg
+ * count (0 if the flag was not recognized). Mutates `out` in place.
+ */
+export declare function parseCommonFlag(args: string[], index: number, out: CommonOptions): number;
+export declare function commonDefaults(analyzeDefault: boolean): CommonOptions;
+export declare function finalizeOptions<T extends CommonOptions>(opts: T): T;
+export declare function resolveAuth(deps: Deps, options?: {
+    projectId?: string;
+    repoPath?: string;
+}): Promise<{
+    authToken: string | undefined;
+    organizationId: string;
+    projectId: string;
+}>;
+export declare function createApiClient(apiUrl: string, authToken: string | undefined, organizationId: string): any;
+export declare function repoNameFromUrl(url: string): string;
+export declare function resolveDefaultBranch(execGit: Deps["execGit"]): string;
+export declare function readGitMetadata(repoPath: string, deps: Deps): {
+    remoteUrl: string;
+    name: string;
+    defaultBranch: string;
+} | null;
+export declare function discoverFiles(repoPath: string): DiscoveredFile[];
+/** Discover files, print summary. Returns files or null if empty. */
+export declare function discoverAndDisplay(repoPath: string, stdout: (s: string) => void): DiscoveredFile[] | null;
+export declare function buildAnalysisPrompt(projectId: string, repoPath: string, files: DiscoveredFile[], organizationId?: string): string;
+export declare function validateAnalysisReport(text: string): {
+    ok: boolean;
+    missing: string[];
+};
+/**
+ * Connect to the MCP HTTP server via raw JSON-RPC, perform the MCP
+ * initialize handshake, then list tools and verify Spekn tools exist.
+ * Returns tool names on success or null on failure.
+ */
+export declare function verifyMcpServer(mcpUrl: string, authToken: string, stderr: (s: string) => void, debug: boolean, sessionPurpose?: string): Promise<string[] | null>;
+export declare function executeAcpSession(agent: {
+    command: string;
+    args: string[];
+}, prompt: string, repoPath: string, mcpUrl: string, authToken: string, stderr: (s: string) => void, organizationId?: string, sessionPurpose?: string, acpTimeoutMs?: number): Promise<{
+    text: string;
+    error?: string;
+}>;
+export interface AnalysisOptions {
+    apiUrl: string;
+    agentName: string | null;
+    prompt: string;
+    repoPath: string;
+    mcpUrl: string;
+    authToken: string;
+    organizationId?: string;
+    requiredTools?: string[];
+    stdout: (s: string) => void;
+    stderr: (s: string) => void;
+    debug: boolean;
+    acpTimeoutMs?: number;
+}
+/**
+ * Verify MCP server, resolve an agent, run the ACP session.
+ * Retries with the next agent if one doesn't support HTTP MCP.
+ */
+export declare function runAnalysisWithAgent(options: AnalysisOptions): Promise<{
+    text: string;
+    error?: string;
+}>;
+/**
+ * Complete analysis phase: discover files → build prompt → run agent.
+ * Returns exit code (0 = success, 1 = error).
+ */
+export declare function runAnalysisPhase(options: CommonOptions, authToken: string, deps: Deps, organizationId?: string): Promise<number>;