@spekn/cli 1.0.0

package/dist/marketplace-export.d.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { CredentialsStore } from './auth/credentials-store';
+interface CLIOptions {
+    projectId?: string;
+    output: string;
+    apiUrl: string;
+    marketplaceName: string;
+    ownerName: string;
+}
+interface Deps {
+    createClient: (apiUrl: string, organizationId: string, authToken?: string) => any;
+    writeFile: (filePath: string, content: string) => void;
+    mkdirSync: (dirPath: string) => void;
+    stdout: (content: string) => void;
+    stderr: (content: string) => void;
+    credentialsStore: CredentialsStore;
+}
+declare function parseArgs(args: string[]): CLIOptions;
+export declare function runMarketplaceExportCli(args: string[], deps?: Deps): Promise<number>;
+declare function main(): Promise<void>;
+export { main, parseArgs };

package/dist/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/project-clean.d.ts

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

package/dist/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/project-context.d.ts

@@ -0,0 +1,99 @@
+export interface ProjectContextData {
+    projectId?: string;
+    organizationId?: string;
+    updatedAt?: string;
+}
+/** Enhanced global context with multi-project support */
+export interface GlobalContextData {
+    /** Default organization for new projects */
+    defaultOrganizationId?: string;
+    /** List of projects the user has worked with */
+    projects?: Array<{
+        id: string;
+        name?: string;
+        organizationId: string;
+        lastUsed: string;
+        repoPaths: string[];
+        repoSync?: {
+            checkpoints?: Record<string, {
+                lastHeadCommit?: string;
+                syncedAt?: string;
+            }>;
+        };
+    }>;
+    /** Last used project ID for smart defaults */
+    lastUsedProjectId?: string;
+    /** User preferences */
+    preferences?: {
+        defaultAgent?: string;
+        defaultFormat?: string;
+    };
+    /** When the global context was last updated */
+    updatedAt?: string;
+    /** Repo sync metadata keyed by absolute repo path */
+    repoSync?: {
+        checkpoints?: Record<string, {
+            lastHeadCommit?: string;
+            syncedAt?: string;
+        }>;
+    };
+}
+export interface ResolvedProjectContext {
+    projectId: string;
+    organizationId: string;
+}
+export declare function findNearestLocalContextFile(startDir?: string): string | null;
+export declare function loadLocalContext(repoPath?: string): ProjectContextData | null;
+export declare function loadGlobalContext(): GlobalContextData | null;
+export declare function resolveProjectContext(input: {
+    explicitProjectId?: string;
+    explicitOrganizationId?: string;
+    repoPath?: string;
+    credentialsOrganizationId?: string;
+    envOrganizationId?: string;
+}): ResolvedProjectContext;
+/** Get the most recently used project from global context */
+export declare function getLastUsedProject(): {
+    projectId: string;
+    organizationId: string;
+} | null;
+/** List all recent projects from global context */
+export declare function listRecentProjects(): Array<{
+    id: string;
+    name?: string;
+    organizationId: string;
+    lastUsed: string;
+    repoPaths: string[];
+}>;
+/** Set the last used project in global context */
+export declare function setLastUsedProject(projectId: string): void;
+/** Get project by ID from global context */
+export declare function getProjectFromGlobalContext(projectId: string): {
+    id: string;
+    name?: string;
+    organizationId: string;
+    lastUsed: string;
+    repoPaths: string[];
+} | null;
+export declare function saveLocalContext(repoPath: string, context: {
+    projectId: string;
+    organizationId?: string;
+}): void;
+export declare function saveGlobalContext(context: GlobalContextData): void;
+/** Add or update a project in the global context history */
+export declare function addProjectToGlobalContext(projectId: string, organizationId: string, repoPath: string): void;
+export declare function ensureGitignoreHasSpekn(repoPath: string): void;
+export declare function persistProjectContext(repoPath: string, context: {
+    projectId: string;
+    organizationId?: string;
+}): void;
+export declare function persistProjectContextWithoutRepoPath(repoPath: string, context: {
+    projectId: string;
+    organizationId?: string;
+}): void;
+export declare function clearRepoFromGlobalContext(repoPath: string, projectId?: string): {
+    removedProjectRefs: number;
+    removedSyncCheckpoints: number;
+    removedProjects: number;
+    clearedLastUsedProjectId: boolean;
+};