@proletariat/cli 0.3.23 → 0.3.25

package/dist/commands/mcp-server.js

@@ -0,0 +1,98 @@
+/**
+ * MCP Server Command
+ *
+ * Comprehensive MCP (Model Context Protocol) server exposing ALL prlt commands
+ * as tools for AI agent integration.
+ *
+ * Usage in Claude Code config:
+ * ```json
+ * {
+ *   "mcpServers": {
+ *     "prlt": { "command": "prlt", "args": ["mcp-server"] }
+ *   }
+ * }
+ * ```
+ */
+import { Command } from '@oclif/core';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { execSync } from 'node:child_process';
+import * as path from 'node:path';
+import { getPMOContext } from '../lib/pmo/pmo-context.js';
+import { registerTicketTools, registerProjectTools, registerBoardTools, registerSpecTools, registerEpicTools, registerWorkTools, registerWorkflowTools, registerStatusTools, registerPhaseTools, registerActionTools, registerRoadmapTools, registerCategoryTools, registerTemplateTools, registerViewTools, registerAgentTools, registerDockerTools, registerRepoTools, registerBranchTools, registerGitHubTools, registerInitTools, registerUtilityTools, } from '../lib/mcp/index.js';
+export default class McpServerCommand extends Command {
+    static description = 'Start MCP server for AI agent integration (exposes all prlt commands as tools)';
+    static hidden = true;
+    static examples = ['<%= config.bin %> mcp-server'];
+    async run() {
+        // Initialize PMO context (may be null if not in a workspace)
+        let pmoContext = null;
+        try {
+            pmoContext = await getPMOContext({ logger: () => { } });
+        }
+        catch {
+            pmoContext = null;
+        }
+        // Create MCP server
+        const server = new McpServer({
+            name: 'prlt',
+            version: this.config.version,
+        });
+        // Create tool context
+        const ctx = {
+            get storage() {
+                if (!pmoContext) {
+                    throw new Error('PMO not initialized. Run "prlt init" first.');
+                }
+                return pmoContext.storage;
+            },
+            runCommand: (cmd) => {
+                try {
+                    const result = execSync(cmd, {
+                        encoding: 'utf-8',
+                        cwd: process.cwd(),
+                        env: {
+                            ...process.env,
+                            PATH: `${path.dirname(process.execPath)}:${process.env.PATH}`,
+                        },
+                        maxBuffer: 10 * 1024 * 1024,
+                    });
+                    return result.trim();
+                }
+                catch (error) {
+                    const execError = error;
+                    if (execError.stderr)
+                        return execError.stderr.trim();
+                    if (execError.stdout)
+                        return execError.stdout.trim();
+                    throw error;
+                }
+            },
+        };
+        // Register all tool categories
+        registerTicketTools(server, ctx);
+        registerProjectTools(server, ctx);
+        registerBoardTools(server, ctx);
+        registerSpecTools(server, ctx);
+        registerEpicTools(server, ctx);
+        registerWorkTools(server, ctx);
+        registerWorkflowTools(server, ctx);
+        registerStatusTools(server, ctx);
+        registerPhaseTools(server, ctx);
+        registerActionTools(server, ctx);
+        registerRoadmapTools(server, ctx);
+        registerCategoryTools(server, ctx);
+        registerTemplateTools(server, ctx);
+        registerViewTools(server, ctx);
+        registerAgentTools(server, ctx);
+        registerDockerTools(server, ctx);
+        registerRepoTools(server, ctx);
+        registerBranchTools(server, ctx);
+        registerGitHubTools(server, ctx);
+        registerInitTools(server, ctx);
+        registerUtilityTools(server, ctx);
+        // Connect via stdio transport
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+    }
+}

package/dist/commands/phase/create.js

@@ -21,7 +21,7 @@ export default class PhaseCreate extends PMOCommand {
         ...pmoBaseFlags,
         category: Flags.string({
             char: 'c',
-            description: 'State category',
+            description: 'State category [required for non-interactive]',
             options: ['backlog', 'unstarted', 'started', 'completed', 'canceled'],
         }),
         color: Flags.string({

package/dist/commands/project/create.d.ts

@@ -11,6 +11,7 @@ export default class ProjectCreate extends PMOCommand {
         description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         template: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };

package/dist/commands/project/create.js

@@ -5,7 +5,7 @@ import inquirer from 'inquirer';
 import { createBoardContent, createSpecFolders, PMOCommand, pmoBaseFlags, BUILTIN_TEMPLATES } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { slugify } from '../../lib/pmo/utils.js';
-import { shouldOutputJson, outputPromptAsJson, outputSuccessAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputPromptAsJson, outputSuccessAsJson, outputDryRunSuccessAsJson, outputDryRunErrorsAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
 // Build template options dynamically from shared definitions
 const TEMPLATE_IDS = BUILTIN_TEMPLATES.map(t => t.id);
 export default class ProjectCreate extends PMOCommand {
@@ -14,6 +14,7 @@ export default class ProjectCreate extends PMOCommand {
         '<%= config.bin %> <%= command.id %> "My New Project"',
         '<%= config.bin %> <%= command.id %> --name "Mobile App" --description "iOS and Android app"',
         '<%= config.bin %> <%= command.id %> -i  # Interactive mode',
+        '<%= config.bin %> <%= command.id %> --name "Test" --dry-run --json  # Validate without creating',
     ];
     static args = {
         name: Args.string({
@@ -25,7 +26,7 @@ export default class ProjectCreate extends PMOCommand {
         ...pmoBaseFlags,
         name: Flags.string({
             char: 'n',
-            description: 'Project name',
+            description: 'Project name [required for non-interactive]',
         }),
         id: Flags.string({
             description: 'Custom project ID (auto-generated from name if not provided)',
@@ -45,6 +46,10 @@ export default class ProjectCreate extends PMOCommand {
             description: 'Interactive mode',
             default: false,
         }),
+        'dry-run': Flags.boolean({
+            description: 'Validate inputs without creating project (use with --json for structured output)',
+            default: false,
+        }),
     };
     getPMOOptions() {
         return { promptIfMultiple: false };
@@ -86,8 +91,39 @@ export default class ProjectCreate extends PMOCommand {
         // Check if project already exists
         const existing = await this.storage.getProject(projectId);
         if (existing) {
+            if (flags['dry-run']) {
+                if (jsonMode) {
+                    outputDryRunErrorsAsJson([{ field: 'id', error: `Project "${projectId}" already exists` }], createMetadata('project create', flags));
+                }
+            }
             this.error(`Project "${projectId}" already exists.`);
         }
+        // Get the statuses from the workflow (for dry-run preview)
+        const statuses = await this.storage.listStatuses(projectData.template);
+        // Handle dry-run: show what would be created without actually creating
+        if (flags['dry-run']) {
+            const wouldCreate = {
+                id: projectId,
+                name: projectData.name,
+                template: projectData.template,
+                statuses: statuses.map(s => s.name),
+                ...(projectData.description && { description: projectData.description }),
+            };
+            if (jsonMode) {
+                outputDryRunSuccessAsJson('project', wouldCreate, createMetadata('project create', flags));
+            }
+            // Human-readable dry-run output
+            this.log(styles.warning('\n[DRY RUN] Would create project:'));
+            this.log(styles.muted(`   ID: ${projectId}`));
+            this.log(styles.muted(`   Name: ${projectData.name}`));
+            this.log(styles.muted(`   Template: ${projectData.template}`));
+            this.log(styles.muted(`   Statuses: ${statuses.map(s => s.name).join(' → ')}`));
+            if (projectData.description) {
+                this.log(styles.muted(`   Description: ${projectData.description}`));
+            }
+            this.log(styles.muted('\n(No project was created)'));
+            return;
+        }
         // Create project in database
         const project = await this.storage.createProject({
             id: projectId,
@@ -104,8 +140,6 @@ export default class ProjectCreate extends PMOCommand {
         fs.writeFileSync(boardPath, boardContent);
         // Create spec folders in project directory
         const specsPath = createSpecFolders(this.pmoPath, projectId);
-        // Get the statuses from the workflow (template name = workflow ID for built-in templates)
-        const statuses = await this.storage.listStatuses(projectData.template);
         // In JSON mode, output success with project details
         if (jsonMode) {
             outputSuccessAsJson({

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

@@ -0,0 +1,38 @@
+import { PMOCommand } from '../../lib/pmo/index.js';
+interface CreateRepoResult {
+    success: boolean;
+    url?: string;
+    name?: string;
+    error?: string;
+}
+/**
+ * Get the user's GitHub organizations.
+ */
+export declare function getGHOrganizations(): string[];
+/**
+ * Create a GitHub repository using `gh` CLI.
+ */
+export declare function createGHRepo(options: {
+    name: string;
+    visibility: 'public' | 'private';
+    org?: string;
+    cwd?: string;
+    push?: boolean;
+}): CreateRepoResult;
+export default class Create extends PMOCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        visibility: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        org: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        push: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected getPMOOptions(): {
+        promptIfMultiple: boolean;
+    };
+    execute(): Promise<void>;
+}
+export {};

package/dist/commands/repo/create.js

@@ -0,0 +1,283 @@
+import { Flags } from '@oclif/core';
+import { execSync, spawnSync } from 'node:child_process';
+import * as path from 'node:path';
+import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
+import { colors, format } from '../../lib/colors.js';
+import { findHQRoot, isInGitRepo } from '../../lib/repos/index.js';
+import { hasGitHubRemote } from '../../lib/repos/git.js';
+import { isGHInstalled, isGHAuthenticated, getGHUsername, } from '../../lib/pr/index.js';
+import { shouldOutputJson, outputSuccessAsJson, outputErrorAsJson, outputPromptAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { addRepositoriesToDatabase } from '../../lib/database/index.js';
+// =============================================================================
+// GitHub Helpers
+// =============================================================================
+/**
+ * Get the user's GitHub organizations.
+ */
+export function getGHOrganizations() {
+    try {
+        const result = execSync('gh api user/orgs --jq ".[].login"', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        return result ? result.split('\n').filter(Boolean) : [];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Create a GitHub repository using `gh` CLI.
+ */
+export function createGHRepo(options) {
+    const { name, visibility, org, cwd, push = true } = options;
+    const repoName = org ? `${org}/${name}` : name;
+    const args = [
+        'repo', 'create', repoName,
+        `--${visibility}`,
+        '--source=.',
+        '--remote=origin',
+    ];
+    if (push) {
+        args.push('--push');
+    }
+    try {
+        const result = spawnSync('gh', args, {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        if (result.status !== 0) {
+            return {
+                success: false,
+                error: result.stderr || 'Failed to create repository',
+            };
+        }
+        // Parse the repo URL from stdout
+        const url = result.stdout.trim();
+        return {
+            success: true,
+            url,
+            name: repoName,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+// =============================================================================
+// Command
+// =============================================================================
+export default class Create extends PMOCommand {
+    static description = 'Create a GitHub repository and set up remote';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --name my-repo --visibility private',
+        '<%= config.bin %> <%= command.id %> --name my-repo --org my-company',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...pmoBaseFlags,
+        name: Flags.string({
+            char: 'n',
+            description: 'Repository name (defaults to current directory name)',
+        }),
+        visibility: Flags.string({
+            char: 'v',
+            description: 'Repository visibility',
+            options: ['public', 'private'],
+            default: 'private',
+        }),
+        org: Flags.string({
+            char: 'o',
+            description: 'GitHub organization (creates personal repo if not specified)',
+        }),
+        push: Flags.boolean({
+            description: 'Push initial commit after creating repo',
+            default: true,
+            allowNo: true,
+        }),
+    };
+    getPMOOptions() {
+        return { promptIfMultiple: false };
+    }
+    async execute() {
+        const { flags } = await this.parse(Create);
+        const jsonMode = shouldOutputJson(flags);
+        const metadata = createMetadata('repo create', flags);
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, metadata);
+                this.exit(1);
+            }
+            this.error(message);
+        };
+        // Check prerequisites
+        if (!isGHInstalled()) {
+            return handleError('GH_NOT_INSTALLED', 'GitHub CLI (gh) is not installed. Install with: brew install gh');
+        }
+        if (!isGHAuthenticated()) {
+            return handleError('GH_NOT_AUTHENTICATED', 'Not authenticated with GitHub. Run: gh auth login');
+        }
+        // Must be in a git repo
+        if (!isInGitRepo()) {
+            return handleError('NOT_GIT_REPO', 'Not in a git repository. Initialize one with: git init');
+        }
+        // Check if remote already exists
+        if (hasGitHubRemote()) {
+            return handleError('REMOTE_EXISTS', 'This repository already has a GitHub remote configured.');
+        }
+        // Gather parameters
+        let repoName = flags.name;
+        let visibility = flags.visibility;
+        let org = flags.org;
+        // Get default repo name from directory
+        if (!repoName) {
+            repoName = path.basename(process.cwd());
+        }
+        // Prompt for repo name
+        const nameMessage = 'Repository name:';
+        if (jsonMode) {
+            if (!flags.name) {
+                outputPromptAsJson(buildPromptConfig('input', 'repoName', nameMessage, undefined, repoName), metadata);
+                return;
+            }
+        }
+        else {
+            const nameResult = await this.prompt([{
+                    type: 'input',
+                    name: 'repoName',
+                    message: nameMessage,
+                    default: repoName,
+                    validate: (input) => {
+                        const value = String(input || '');
+                        if (!value.trim())
+                            return 'Repository name is required';
+                        if (!/^[a-zA-Z0-9._-]+$/.test(value)) {
+                            return 'Repository name can only contain letters, numbers, dots, hyphens, and underscores';
+                        }
+                        return true;
+                    },
+                }], null);
+            repoName = nameResult.repoName;
+        }
+        // Prompt for visibility
+        const visibilityChoices = [
+            { name: 'Private', value: 'private' },
+            { name: 'Public', value: 'public' },
+        ];
+        const visibilityMessage = 'Repository visibility:';
+        if (jsonMode) {
+            if (!flags.visibility) {
+                outputPromptAsJson(buildPromptConfig('list', 'visibility', visibilityMessage, visibilityChoices, visibility), metadata);
+                return;
+            }
+        }
+        else {
+            const visibilityResult = await this.prompt([{
+                    type: 'list',
+                    name: 'visibility',
+                    message: visibilityMessage,
+                    choices: visibilityChoices,
+                    default: visibility,
+                }], null);
+            visibility = visibilityResult.visibility;
+        }
+        // Prompt for org if orgs are available
+        const orgs = getGHOrganizations();
+        const username = getGHUsername();
+        if (orgs.length > 0 && !flags.org) {
+            const ownerChoices = [
+                { name: `${username || 'Personal'} (personal account)`, value: '' },
+                ...orgs.map(o => ({ name: o, value: o })),
+            ];
+            const orgMessage = 'Create repository under:';
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'org', orgMessage, ownerChoices), metadata);
+                return;
+            }
+            const orgResult = await this.prompt([{
+                    type: 'list',
+                    name: 'org',
+                    message: orgMessage,
+                    choices: ownerChoices,
+                }], null);
+            org = orgResult.org || undefined;
+        }
+        // Confirm creation (interactive only)
+        if (!jsonMode) {
+            this.log('');
+            this.log(colors.primary('Creating GitHub repository:'));
+            this.log(`  Name: ${org ? `${org}/${repoName}` : repoName}`);
+            this.log(`  Visibility: ${visibility}`);
+            this.log(`  Push initial commit: ${flags.push ? 'Yes' : 'No'}`);
+            this.log('');
+            const confirmChoices = [
+                { name: 'Yes', value: true },
+                { name: 'No', value: false },
+            ];
+            const confirmResult = await this.prompt([{
+                    type: 'list',
+                    name: 'confirm',
+                    message: 'Proceed with creation?',
+                    choices: confirmChoices,
+                }], null);
+            if (!confirmResult.confirm) {
+                this.log(colors.textMuted('Operation cancelled.'));
+                return;
+            }
+        }
+        // Create the repository
+        if (!jsonMode) {
+            this.log(colors.primary('Creating GitHub repository...'));
+        }
+        const result = createGHRepo({
+            name: repoName,
+            visibility,
+            org,
+            push: flags.push,
+        });
+        if (!result.success) {
+            return handleError('CREATE_FAILED', `Failed to create repository: ${result.error}`);
+        }
+        // Update prlt database if in HQ
+        const hqPath = findHQRoot();
+        if (hqPath) {
+            try {
+                // Use the actual local folder name for the DB path, not repoName
+                // (repoName may differ if user overrides it via --name)
+                const localFolderName = path.basename(process.cwd());
+                addRepositoriesToDatabase(hqPath, [{
+                        name: repoName,
+                        path: `repos/${localFolderName}`,
+                        source_url: result.url,
+                    }]);
+                if (!jsonMode) {
+                    this.log(colors.textMuted('Updated prlt workspace database.'));
+                }
+            }
+            catch {
+                // Ignore database update errors - repo was still created
+            }
+        }
+        // Success output
+        if (jsonMode) {
+            outputSuccessAsJson({
+                created: true,
+                name: result.name,
+                url: result.url,
+                visibility,
+                org: org || null,
+            }, metadata);
+            return;
+        }
+        this.log('');
+        this.log(format.success(`Repository created: ${result.url}`));
+        this.log('');
+        this.log(colors.textMuted('Your local repository is now connected to GitHub.'));
+        this.log(colors.textMuted('You can push changes with: git push'));
+    }
+}

package/dist/commands/repo/index.js

@@ -23,6 +23,7 @@ export default class Repo extends PMOCommand {
         const menuChoices = [
             { name: 'List all repositories', value: 'list', command: 'prlt repo list --json' },
             { name: 'Add repository', value: 'add', command: 'prlt repo add --json' },
+            { name: 'Create GitHub repository', value: 'create', command: 'prlt repo create --json' },
             { name: 'Remove repository', value: 'remove', command: 'prlt repo remove --json' },
             { name: 'View repository details', value: 'view', command: 'prlt repo view --json' },
             { name: 'Add multiple repositories', value: 'add-bulk', command: 'prlt repo add --bulk --json' },
@@ -55,6 +56,12 @@ export default class Repo extends PMOCommand {
                     await cmd.run();
                     break;
                 }
+                case 'create': {
+                    const { default: CreateCommand } = await import('./create.js');
+                    const cmd = new CreateCommand([], this.config);
+                    await cmd.run();
+                    break;
+                }
                 case 'add': {
                     const { default: AddCommand } = await import('./add.js');
                     const cmd = new AddCommand([], this.config);

package/dist/commands/roadmap/add-project.js

@@ -1,8 +1,7 @@
 import { Args, Flags } from '@oclif/core';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
-import { shouldOutputJson, outputPromptAsJson, outputErrorAsJson, createMetadata, buildPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
 export default class RoadmapAddProject extends PMOCommand {
     static description = 'Add a project to a roadmap';
     static examples = [
@@ -50,23 +49,17 @@ export default class RoadmapAddProject extends PMOCommand {
                 }
                 this.error('No roadmaps found. Create one with: prlt roadmap create');
             }
-            if (jsonMode) {
-                const choices = roadmaps.map(r => ({
-                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
-                    value: r.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'roadmap', 'Select roadmap:', choices), createMetadata('roadmap add-project', flags));
-                return;
-            }
-            const { selected } = await inquirer.prompt([{
+            const jsonModeConfig = jsonMode ? { flags, commandName: 'roadmap add-project' } : null;
+            const { selected } = await this.prompt([{
                     type: 'list',
                     name: 'selected',
                     message: 'Select roadmap:',
                     choices: roadmaps.map(r => ({
                         name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
                         value: r.id,
+                        command: `prlt roadmap add-project "${r.id}" --json`,
                     })),
-                }]);
+                }], jsonModeConfig);
             roadmapId = selected;
         }
         const roadmap = await this.storage.getRoadmap(roadmapId);
@@ -93,23 +86,17 @@ export default class RoadmapAddProject extends PMOCommand {
         // Select project
         let projectId = args.project;
         if (!projectId) {
-            if (jsonMode) {
-                const choices = availableProjects.map(p => ({
-                    name: p.name,
-                    value: p.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'project', 'Select project to add:', choices), createMetadata('roadmap add-project', flags));
-                return;
-            }
-            const { selected } = await inquirer.prompt([{
+            const projectJsonModeConfig = jsonMode ? { flags, commandName: 'roadmap add-project' } : null;
+            const { selected } = await this.prompt([{
                     type: 'list',
                     name: 'selected',
                     message: 'Select project to add:',
                     choices: availableProjects.map(p => ({
                         name: p.name,
                         value: p.id,
+                        command: `prlt roadmap add-project "${roadmapId}" "${p.id}" --json`,
                     })),
-                }]);
+                }], projectJsonModeConfig);
             projectId = selected;
         }
         // Verify project exists and isn't already in roadmap

package/dist/commands/roadmap/create.d.ts

@@ -18,5 +18,4 @@ export default class RoadmapCreate extends PMOCommand {
         promptIfMultiple: boolean;
     };
     execute(): Promise<void>;
-    private promptRoadmapData;
 }