@shepai/cli 1.183.0-pr554.2632d62 → 1.183.0-pr555.e53ab0e

package/dist/packages/core/src/infrastructure/services/plugin/mcp-server-manager.service.js

@@ -0,0 +1,206 @@
+/**
+ * MCP Server Manager Service
+ *
+ * Manages MCP server process lifecycle for plugin system.
+ * Uses child_process.spawn() with reference counting for concurrent features.
+ * Generates per-feature temp .mcp.json config files for agent executors.
+ *
+ * Follows the ClaudeCodeExecutorService pattern for process spawning:
+ * - No shell: true (prevents injection)
+ * - Command and args as arrays
+ * - Explicit env var passing
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { injectable, inject } from 'tsyringe';
+import { writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { PluginType } from '../../../domain/generated/output.js';
+import { IS_WINDOWS } from '../../platform.js';
+let McpServerManagerService = class McpServerManagerService {
+    spawn;
+    /** Shared server pool keyed by plugin name */
+    servers = new Map();
+    /** Per-feature tracking */
+    features = new Map();
+    constructor(spawn) {
+        this.spawn = spawn;
+    }
+    async startServersForFeature(featureId, plugins) {
+        const mcpPlugins = plugins.filter((p) => p.type === PluginType.Mcp && p.serverCommand);
+        if (mcpPlugins.length === 0)
+            return;
+        const entry = this.features.get(featureId) ?? {
+            pluginNames: new Set(),
+            configPath: null,
+        };
+        for (const plugin of mcpPlugins) {
+            const existing = this.servers.get(plugin.name);
+            if (existing) {
+                // Shared server — increment reference count
+                existing.referenceCount++;
+                entry.pluginNames.add(plugin.name);
+                continue;
+            }
+            // Build environment for the child process
+            const env = this.buildServerEnv(plugin);
+            const proc = this.spawn(plugin.serverCommand, plugin.serverArgs ?? [], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env,
+                ...(IS_WINDOWS ? { windowsHide: true } : {}),
+            });
+            // Track unexpected exits
+            proc.on('exit', () => {
+                this.servers.delete(plugin.name);
+            });
+            this.servers.set(plugin.name, {
+                pluginName: plugin.name,
+                process: proc,
+                referenceCount: 1,
+                env,
+                command: plugin.serverCommand,
+                args: plugin.serverArgs ?? [],
+            });
+            entry.pluginNames.add(plugin.name);
+        }
+        this.features.set(featureId, entry);
+    }
+    async stopServersForFeature(featureId) {
+        const entry = this.features.get(featureId);
+        if (!entry)
+            return;
+        for (const pluginName of entry.pluginNames) {
+            const server = this.servers.get(pluginName);
+            if (!server)
+                continue;
+            server.referenceCount--;
+            if (server.referenceCount <= 0) {
+                this.killProcess(server);
+                this.servers.delete(pluginName);
+            }
+        }
+        // Clean up temp config file
+        if (entry.configPath) {
+            try {
+                unlinkSync(entry.configPath);
+            }
+            catch {
+                // File already deleted or never created
+            }
+        }
+        this.features.delete(featureId);
+    }
+    getActiveServers(featureId) {
+        const entry = this.features.get(featureId);
+        if (!entry)
+            return [];
+        const result = [];
+        for (const pluginName of entry.pluginNames) {
+            const server = this.servers.get(pluginName);
+            if (server) {
+                result.push({
+                    pluginName: server.pluginName,
+                    pid: server.process.pid ?? 0,
+                    referenceCount: server.referenceCount,
+                });
+            }
+        }
+        return result;
+    }
+    async generateMcpConfigPath(featureId) {
+        const entry = this.features.get(featureId);
+        if (!entry || entry.pluginNames.size === 0)
+            return null;
+        // Return cached path if already generated
+        if (entry.configPath)
+            return entry.configPath;
+        const mcpServers = {};
+        for (const pluginName of entry.pluginNames) {
+            const server = this.servers.get(pluginName);
+            if (!server)
+                continue;
+            mcpServers[pluginName] = {
+                type: 'stdio',
+                command: server.command,
+                args: server.args,
+                env: server.env,
+            };
+        }
+        if (Object.keys(mcpServers).length === 0)
+            return null;
+        const configPath = join(tmpdir(), `shep-mcp-${featureId}.json`);
+        writeFileSync(configPath, JSON.stringify({ mcpServers }, null, 2), 'utf-8');
+        entry.configPath = configPath;
+        return configPath;
+    }
+    /**
+     * Kill all managed servers and clean up all temp files.
+     * Called on SIGTERM, SIGINT, beforeExit, and explicit shutdown.
+     */
+    async shutdown() {
+        for (const server of this.servers.values()) {
+            this.killProcess(server);
+        }
+        this.servers.clear();
+        for (const entry of this.features.values()) {
+            if (entry.configPath) {
+                try {
+                    unlinkSync(entry.configPath);
+                }
+                catch {
+                    // Already cleaned up
+                }
+            }
+        }
+        this.features.clear();
+    }
+    /**
+     * Build the environment object for a server child process.
+     * Only includes PATH and explicitly required env vars — no wholesale inheritance.
+     */
+    buildServerEnv(plugin) {
+        const env = {};
+        // Always pass PATH so the server can find its runtime
+        if (process.env.PATH) {
+            env.PATH = process.env.PATH;
+        }
+        // Pass required env vars from the host environment
+        for (const varName of plugin.requiredEnvVars ?? []) {
+            const value = process.env[varName];
+            if (value) {
+                env[varName] = value;
+            }
+        }
+        // Pass active tool groups via the standard env var
+        if (plugin.activeToolGroups && plugin.activeToolGroups.length > 0) {
+            env.CLAUDE_FLOW_TOOL_GROUPS = plugin.activeToolGroups.join(',');
+        }
+        return env;
+    }
+    /** Send SIGTERM to a managed server process */
+    killProcess(server) {
+        try {
+            server.process.kill('SIGTERM');
+        }
+        catch {
+            // Process may have already exited
+        }
+    }
+};
+McpServerManagerService = __decorate([
+    injectable(),
+    __param(0, inject('SpawnFunction')),
+    __metadata("design:paramtypes", [Function])
+], McpServerManagerService);
+export { McpServerManagerService };

package/dist/packages/core/src/infrastructure/services/plugin/plugin-catalog.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Curated Plugin Catalog
+ *
+ * Static catalog of well-known AI-native tool plugins that ship with Shep.
+ * Users can browse and install these by name (e.g., `shep plugin add mempalace`).
+ *
+ * Follows the TOOL_METADATA pattern in tool-metadata.ts:
+ * type-safe, tree-shaken, no I/O required.
+ *
+ * To add a new catalog entry, append to the CATALOG array below.
+ */
+import { PluginType, PluginTransport, type ToolGroup } from '../../../domain/generated/output.js';
+/**
+ * Catalog entry describing a well-known plugin available for installation.
+ */
+export interface CatalogEntry {
+    /** Unique plugin name used as identifier */
+    name: string;
+    /** Human-readable display name */
+    displayName: string;
+    /** Integration type */
+    type: PluginType;
+    /** Brief description of what this plugin provides */
+    description: string;
+    /** Command to install the plugin package (e.g., 'pip install mempalace') */
+    installCommand: string;
+    /** Command to start the MCP server (MCP type only) */
+    serverCommand?: string;
+    /** Arguments for the server command (MCP type only) */
+    serverArgs?: string[];
+    /** MCP transport protocol (MCP type only) */
+    transport?: PluginTransport;
+    /** Environment variable names required by this plugin (names only, never values) */
+    requiredEnvVars: string[];
+    /** Available tool groups for selective activation */
+    toolGroups?: ToolGroup[];
+    /** Required runtime: 'python' or 'node' */
+    runtimeType: string;
+    /** Minimum runtime version (e.g., '3.9' for Python, '20' for Node.js) */
+    runtimeMinVersion: string;
+    /** Plugin homepage or repository URL */
+    homepageUrl: string;
+}
+/**
+ * Returns a copy of all curated catalog entries.
+ */
+export declare function getCatalogEntries(): CatalogEntry[];
+/**
+ * Returns a single catalog entry by name, or undefined if not found.
+ */
+export declare function getCatalogEntry(name: string): CatalogEntry | undefined;
+//# sourceMappingURL=plugin-catalog.d.ts.map

package/dist/packages/core/src/infrastructure/services/plugin/plugin-catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-catalog.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/plugin/plugin-catalog.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,KAAK,SAAS,EAAE,MAAM,qCAAqC,CAAC;AAElG;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,uBAAuB;IACvB,IAAI,EAAE,UAAU,CAAC;IACjB,qDAAqD;IACrD,WAAW,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,cAAc,EAAE,MAAM,CAAC;IACvB,sDAAsD;IACtD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,oFAAoF;IACpF,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,qDAAqD;IACrD,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;IACzB,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,wCAAwC;IACxC,WAAW,EAAE,MAAM,CAAC;CACrB;AAoED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,YAAY,EAAE,CAElD;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAEtE"}

package/dist/packages/core/src/infrastructure/services/plugin/plugin-catalog.js

@@ -0,0 +1,86 @@
+/**
+ * Curated Plugin Catalog
+ *
+ * Static catalog of well-known AI-native tool plugins that ship with Shep.
+ * Users can browse and install these by name (e.g., `shep plugin add mempalace`).
+ *
+ * Follows the TOOL_METADATA pattern in tool-metadata.ts:
+ * type-safe, tree-shaken, no I/O required.
+ *
+ * To add a new catalog entry, append to the CATALOG array below.
+ */
+import { PluginType, PluginTransport } from '../../../domain/generated/output.js';
+/**
+ * V1 curated catalog entries.
+ */
+const CATALOG = [
+    {
+        name: 'mempalace',
+        displayName: 'MemPalace',
+        type: PluginType.Mcp,
+        description: 'Local AI memory system with persistent knowledge storage. Provides 19 MCP tools for managing long-term memory across AI sessions.',
+        installCommand: 'pip install mempalace',
+        serverCommand: 'python',
+        serverArgs: ['-m', 'mempalace.mcp_server'],
+        transport: PluginTransport.Stdio,
+        requiredEnvVars: [],
+        runtimeType: 'python',
+        runtimeMinVersion: '3.9',
+        homepageUrl: 'https://github.com/MemPalace/mempalace',
+    },
+    {
+        name: 'token-optimizer',
+        displayName: 'Token Optimizer',
+        type: PluginType.Hook,
+        description: 'Token waste reduction and context management via Claude Code lifecycle hooks. Optimizes token usage across sessions without requiring MCP.',
+        installCommand: 'pip install token-optimizer',
+        requiredEnvVars: [],
+        runtimeType: 'python',
+        runtimeMinVersion: '3.8',
+        homepageUrl: 'https://github.com/alexgreensh/token-optimizer',
+    },
+    {
+        name: 'ruflo',
+        displayName: 'Ruflo',
+        type: PluginType.Mcp,
+        description: 'Multi-agent AI orchestration framework with 313 MCP tools. Provides specialized agents for implementation, testing, memory, and workflow orchestration.',
+        installCommand: 'npm install -g ruflo@latest',
+        serverCommand: 'npx',
+        serverArgs: ['ruflo@latest', 'mcp', 'start'],
+        transport: PluginTransport.Stdio,
+        requiredEnvVars: ['ANTHROPIC_API_KEY'],
+        toolGroups: [
+            {
+                name: 'implement',
+                description: 'Code implementation and generation tools',
+            },
+            {
+                name: 'test',
+                description: 'Testing and quality assurance tools',
+            },
+            {
+                name: 'memory',
+                description: 'Persistent memory and context management tools',
+            },
+            {
+                name: 'flow',
+                description: 'Workflow orchestration and agent coordination tools',
+            },
+        ],
+        runtimeType: 'node',
+        runtimeMinVersion: '20',
+        homepageUrl: 'https://github.com/ruvnet/ruflo',
+    },
+];
+/**
+ * Returns a copy of all curated catalog entries.
+ */
+export function getCatalogEntries() {
+    return [...CATALOG];
+}
+/**
+ * Returns a single catalog entry by name, or undefined if not found.
+ */
+export function getCatalogEntry(name) {
+    return CATALOG.find((entry) => entry.name === name);
+}

package/dist/packages/core/src/infrastructure/services/plugin/plugin-health-checker.service.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Plugin Health Checker Service
+ *
+ * Implements multi-tier health checks for plugins:
+ * Tier 1: Runtime on PATH (python3/node via which)
+ * Tier 2: Package installed (future - pip show/npx check)
+ * Tier 3: Required env vars present in process.env
+ *
+ * Follows ToolInstallerService pattern for runtime detection.
+ */
+import { type Plugin } from '../../../domain/generated/output.js';
+import type { IPluginHealthChecker, PluginHealthResult } from '../../../application/ports/output/services/plugin-health-checker.interface.js';
+export declare class PluginHealthCheckerService implements IPluginHealthChecker {
+    private execFileAsync;
+    checkHealth(plugin: Plugin): Promise<PluginHealthResult>;
+    checkAllHealth(plugins: Plugin[]): Promise<PluginHealthResult[]>;
+    /**
+     * Check if a runtime binary exists on PATH.
+     * Tries multiple binary names (e.g., python3 then python for python type).
+     */
+    private checkRuntime;
+    /**
+     * Check that all required environment variables are present in process.env.
+     * Returns the names of missing variables.
+     */
+    private checkEnvVars;
+}
+//# sourceMappingURL=plugin-health-checker.service.d.ts.map

package/dist/packages/core/src/infrastructure/services/plugin/plugin-health-checker.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-health-checker.service.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/plugin/plugin-health-checker.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,EAAsB,KAAK,MAAM,EAAE,MAAM,qCAAqC,CAAC;AACtF,OAAO,KAAK,EACV,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,+EAA+E,CAAC;AAWvF,qBACa,0BAA2B,YAAW,oBAAoB;IACrE,OAAO,CAAC,aAAa,CAAuB;IAEtC,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAoCxD,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAItE;;;OAGG;YACW,YAAY;IAgB1B;;;OAGG;IACH,OAAO,CAAC,YAAY;CAGrB"}

package/dist/packages/core/src/infrastructure/services/plugin/plugin-health-checker.service.js

@@ -0,0 +1,95 @@
+/**
+ * Plugin Health Checker Service
+ *
+ * Implements multi-tier health checks for plugins:
+ * Tier 1: Runtime on PATH (python3/node via which)
+ * Tier 2: Package installed (future - pip show/npx check)
+ * Tier 3: Required env vars present in process.env
+ *
+ * Follows ToolInstallerService pattern for runtime detection.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { injectable } from 'tsyringe';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { PluginHealthStatus } from '../../../domain/generated/output.js';
+import { IS_WINDOWS } from '../../platform.js';
+const RUNTIME_BINARIES = {
+    python: IS_WINDOWS ? ['python', 'python3'] : ['python3', 'python'],
+    node: ['node'],
+};
+const WHICH_COMMAND = IS_WINDOWS ? 'where' : 'which';
+const EXEC_TIMEOUT_MS = 5000;
+let PluginHealthCheckerService = class PluginHealthCheckerService {
+    execFileAsync = promisify(execFile);
+    async checkHealth(plugin) {
+        const checks = [];
+        // Tier 1: Runtime availability
+        if (plugin.runtimeType) {
+            const runtimeFound = await this.checkRuntime(plugin.runtimeType);
+            if (!runtimeFound) {
+                return {
+                    pluginName: plugin.name,
+                    status: PluginHealthStatus.Unavailable,
+                    message: `Required runtime "${plugin.runtimeType}" not found on PATH. Install ${plugin.runtimeType}${plugin.runtimeMinVersion ? ` ${plugin.runtimeMinVersion}+` : ''} and try again.`,
+                };
+            }
+            checks.push(`Runtime "${plugin.runtimeType}" found`);
+        }
+        // Tier 3: Environment variables
+        const missingEnvVars = this.checkEnvVars(plugin.requiredEnvVars ?? []);
+        if (missingEnvVars.length > 0) {
+            return {
+                pluginName: plugin.name,
+                status: PluginHealthStatus.Degraded,
+                message: `Missing required environment variables: ${missingEnvVars.join(', ')}. Add them to your shell profile or .env file.`,
+            };
+        }
+        if ((plugin.requiredEnvVars ?? []).length > 0) {
+            checks.push('All required env vars set');
+        }
+        return {
+            pluginName: plugin.name,
+            status: PluginHealthStatus.Healthy,
+            message: checks.length > 0 ? checks.join('; ') : 'No runtime requirements',
+        };
+    }
+    async checkAllHealth(plugins) {
+        return Promise.all(plugins.map((plugin) => this.checkHealth(plugin)));
+    }
+    /**
+     * Check if a runtime binary exists on PATH.
+     * Tries multiple binary names (e.g., python3 then python for python type).
+     */
+    async checkRuntime(runtimeType) {
+        const binaries = RUNTIME_BINARIES[runtimeType] ?? [runtimeType];
+        for (const binary of binaries) {
+            try {
+                await this.execFileAsync(WHICH_COMMAND, [binary], {
+                    timeout: EXEC_TIMEOUT_MS,
+                });
+                return true;
+            }
+            catch {
+                // Binary not found, try next
+            }
+        }
+        return false;
+    }
+    /**
+     * Check that all required environment variables are present in process.env.
+     * Returns the names of missing variables.
+     */
+    checkEnvVars(requiredVars) {
+        return requiredVars.filter((varName) => !process.env[varName] || process.env[varName] === '');
+    }
+};
+PluginHealthCheckerService = __decorate([
+    injectable()
+], PluginHealthCheckerService);
+export { PluginHealthCheckerService };

package/dist/src/presentation/cli/commands/app/index.d.ts

@@ -7,16 +7,10 @@
  *   shep app [subcommand]
  *
  * Subcommands:
- *   shep app ls                                List applications
- *   shep app show <id>                         Display details of an application
- *   shep app new <desc>                        Create a new application
- *   shep app del <id>                          Delete an application
- *   shep app cloud-providers ls                List cloud deployment providers
- *   shep app cloud-providers connect <id>      Connect a cloud provider token
- *   shep app cloud-providers github-login      Authenticate with GitHub CLI
- *   shep app deploy start <id>                 Start a cloud deployment
- *   shep app deploy status <id>                Show current cloud deployment status
- *   shep app git create-remote <id>            Create and push a GitHub repo for the app
+ *   shep app ls             List applications
+ *   shep app show <id>      Display details of an application
+ *   shep app new <desc>     Create a new application
+ *   shep app del <id>       Delete an application
  */
 import { Command } from 'commander';
 /**

package/dist/src/presentation/cli/commands/app/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/app/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAa1C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/app/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAU1C"}

package/dist/src/presentation/cli/commands/app/index.js

@@ -7,25 +7,16 @@
  *   shep app [subcommand]
  *
  * Subcommands:
- *   shep app ls                                List applications
- *   shep app show <id>                         Display details of an application
- *   shep app new <desc>                        Create a new application
- *   shep app del <id>                          Delete an application
- *   shep app cloud-providers ls                List cloud deployment providers
- *   shep app cloud-providers connect <id>      Connect a cloud provider token
- *   shep app cloud-providers github-login      Authenticate with GitHub CLI
- *   shep app deploy start <id>                 Start a cloud deployment
- *   shep app deploy status <id>                Show current cloud deployment status
- *   shep app git create-remote <id>            Create and push a GitHub repo for the app
+ *   shep app ls             List applications
+ *   shep app show <id>      Display details of an application
+ *   shep app new <desc>     Create a new application
+ *   shep app del <id>       Delete an application
  */
 import { Command } from 'commander';
 import { createLsCommand } from './ls.command.js';
 import { createShowCommand } from './show.command.js';
 import { createNewCommand } from './new.command.js';
 import { createDelCommand } from './del.command.js';
-import { createCloudProvidersCommand } from './cloud-providers/index.js';
-import { createDeployCommand } from './deploy/index.js';
-import { createAppGitCommand } from './git/index.js';
 import { getCliI18n } from '../../i18n.js';
 /**
  * Create the app command with all subcommands
@@ -37,9 +28,6 @@ export function createAppCommand() {
         .addCommand(createLsCommand())
         .addCommand(createShowCommand())
         .addCommand(createNewCommand())
-        .addCommand(createDelCommand())
-        .addCommand(createCloudProvidersCommand())
-        .addCommand(createDeployCommand())
-        .addCommand(createAppGitCommand());
+        .addCommand(createDelCommand());
     return app;
 }

package/dist/src/presentation/cli/commands/feat/new.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"new.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/new.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2EpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAoM1C"}
+{"version":3,"file":"new.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/feat/new.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2EpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAmM1C"}

package/dist/src/presentation/cli/commands/feat/new.command.js

@@ -85,8 +85,7 @@ export function createNewCommand() {
             }
             // First-run onboarding gate — only for interactive terminals
             if (process.stdin.isTTY) {
-                const checkOnboarding = container.resolve(CheckOnboardingStatusUseCase);
-                const { isComplete } = await checkOnboarding.execute();
+                const { isComplete } = await new CheckOnboardingStatusUseCase().execute();
                 if (!isComplete) {
                     await onboardingWizard();
                 }

package/dist/src/presentation/cli/commands/plugin/add.command.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Plugin Add Command
+ *
+ * Install a plugin from the curated catalog or with custom configuration.
+ *
+ * Usage:
+ *   shep plugin add mempalace                          # Install from catalog
+ *   shep plugin add --name my-tool --type mcp --command "npx my-mcp" --transport stdio  # Custom
+ */
+import { Command } from 'commander';
+export declare function createAddCommand(): Command;
+//# sourceMappingURL=add.command.d.ts.map

package/dist/src/presentation/cli/commands/plugin/add.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/plugin/add.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyBpC,wBAAgB,gBAAgB,IAAI,OAAO,CAmD1C"}

package/dist/src/presentation/cli/commands/plugin/add.command.js

@@ -0,0 +1,75 @@
+/**
+ * Plugin Add Command
+ *
+ * Install a plugin from the curated catalog or with custom configuration.
+ *
+ * Usage:
+ *   shep plugin add mempalace                          # Install from catalog
+ *   shep plugin add --name my-tool --type mcp --command "npx my-mcp" --transport stdio  # Custom
+ */
+import { Command } from 'commander';
+import { container } from '../../../../../packages/core/src/infrastructure/di/container.js';
+import { AddPluginUseCase } from '../../../../../packages/core/src/application/use-cases/plugins/add-plugin.use-case.js';
+import { PluginType, PluginTransport } from '../../../../../packages/core/src/domain/generated/output.js';
+import { messages } from '../../ui/index.js';
+import { getCliI18n } from '../../i18n.js';
+const PLUGIN_TYPE_MAP = {
+    mcp: PluginType.Mcp,
+    hook: PluginType.Hook,
+    cli: PluginType.Cli,
+};
+const TRANSPORT_MAP = {
+    stdio: PluginTransport.Stdio,
+    http: PluginTransport.Http,
+};
+export function createAddCommand() {
+    const t = getCliI18n().t;
+    return new Command('add')
+        .description(t('cli:commands.plugin.add.description'))
+        .argument('[catalogName]', t('cli:commands.plugin.add.nameArg'))
+        .option('--name <name>', t('cli:commands.plugin.add.nameOption'))
+        .option('--type <type>', t('cli:commands.plugin.add.typeOption'))
+        .option('--command <command>', t('cli:commands.plugin.add.commandOption'))
+        .option('--transport <transport>', t('cli:commands.plugin.add.transportOption'))
+        .action(async (catalogName, options) => {
+        try {
+            const useCase = container.resolve(AddPluginUseCase);
+            if (catalogName) {
+                // Catalog-based install
+                const plugin = await useCase.execute(catalogName);
+                messages.success(t('cli:commands.plugin.add.success', { name: plugin.name }));
+            }
+            else {
+                // Custom plugin install
+                if (!options.name) {
+                    messages.error(t('cli:commands.plugin.add.customRequiresName'));
+                    process.exitCode = 1;
+                    return;
+                }
+                if (!options.type) {
+                    messages.error(t('cli:commands.plugin.add.customRequiresType'));
+                    process.exitCode = 1;
+                    return;
+                }
+                const pluginType = PLUGIN_TYPE_MAP[options.type.toLowerCase()];
+                if (!pluginType) {
+                    messages.error(t('cli:commands.plugin.add.invalidType', { type: options.type }));
+                    process.exitCode = 1;
+                    return;
+                }
+                const plugin = await useCase.execute({
+                    name: options.name,
+                    type: pluginType,
+                    ...(options.command && { serverCommand: options.command }),
+                    ...(options.transport && { transport: TRANSPORT_MAP[options.transport.toLowerCase()] }),
+                });
+                messages.success(t('cli:commands.plugin.add.success', { name: plugin.name }));
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error(t('cli:commands.plugin.add.failed'), err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/plugin/catalog.command.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Plugin Catalog Command
+ *
+ * Browse available plugins from the curated catalog.
+ *
+ * Usage:
+ *   shep plugin catalog
+ */
+import { Command } from 'commander';
+export declare function createCatalogCommand(): Command;
+//# sourceMappingURL=catalog.command.d.ts.map