@proletariat/cli 0.3.24 → 0.3.26

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;
 }

package/dist/commands/roadmap/create.js

@@ -1,9 +1,8 @@
 import { Flags, Args } from '@oclif/core';
-import inquirer from 'inquirer';
 import { PMOCommand, pmoBaseFlags } from '../../lib/pmo/index.js';
 import { styles } from '../../lib/styles.js';
 import { slugify } from '../../lib/pmo/utils.js';
-import { shouldOutputJson, outputPromptAsJson, createMetadata, buildFormPromptConfig, } from '../../lib/prompt-json.js';
+import { shouldOutputJson } from '../../lib/prompt-json.js';
 export default class RoadmapCreate extends PMOCommand {
     static description = 'Create a new roadmap';
     static examples = [
@@ -54,26 +53,46 @@ export default class RoadmapCreate extends PMOCommand {
         const jsonMode = shouldOutputJson(flags);
         let roadmapData;
         if (flags.interactive || (!args.name && !flags.name)) {
-            const fields = [
-                { type: 'input', name: 'name', message: 'Roadmap name:', default: flags.name },
-                { type: 'input', name: 'id', message: 'Roadmap ID (leave blank to auto-generate):' },
-                { type: 'input', name: 'description', message: 'Description (optional):', default: flags.description },
-                {
+            const jsonModeConfig = jsonMode ? { flags, commandName: 'roadmap create' } : null;
+            // Prompt for name - in JSON mode, outputs prompt and exits; agent re-runs with --name flag
+            const { name } = await this.prompt([{
+                    type: 'input',
+                    name: 'name',
+                    message: 'Roadmap name:',
+                    default: flags.name,
+                    validate: (input) => (typeof input === 'string' && input.length > 0) || 'Name is required',
+                }], jsonModeConfig);
+            // Prompt for id
+            const { id } = await this.prompt([{
+                    type: 'input',
+                    name: 'id',
+                    message: 'Roadmap ID (leave blank to auto-generate):',
+                    default: `roadmap-${slugify(name)}`,
+                }], jsonModeConfig);
+            // Prompt for description
+            const { description } = await this.prompt([{
+                    type: 'input',
+                    name: 'description',
+                    message: 'Description (optional):',
+                    default: flags.description,
+                }], jsonModeConfig);
+            // Prompt for isDefault
+            const { isDefault } = await this.prompt([{
                     type: 'list',
                     name: 'isDefault',
                     message: 'Set as default roadmap?',
                     choices: [
-                        { name: 'No', value: 'false' },
-                        { name: 'Yes', value: 'true' },
+                        { name: 'No', value: 'false', command: `prlt roadmap create --name "${name}" --json` },
+                        { name: 'Yes', value: 'true', command: `prlt roadmap create --name "${name}" --default --json` },
                     ],
                     default: flags.default ? 'true' : 'false',
-                },
-            ];
-            if (jsonMode) {
-                outputPromptAsJson(buildFormPromptConfig(fields), createMetadata('roadmap create', flags));
-                return;
-            }
-            roadmapData = await this.promptRoadmapData(fields);
+                }], jsonModeConfig);
+            roadmapData = {
+                name,
+                id: id || undefined,
+                description: description || undefined,
+                isDefault: isDefault === 'true',
+            };
         }
         else {
             roadmapData = {
@@ -113,22 +132,26 @@ export default class RoadmapCreate extends PMOCommand {
         const projects = await this.storage.listProjects({ isArchived: false });
         if (projects.length > 0) {
             this.log('');
-            const { addProjects } = await inquirer.prompt([{
+            const { addProjects } = await this.prompt([{
                     type: 'list',
                     name: 'addProjects',
                     message: 'Add projects to this roadmap now?',
                     choices: [
-                        { name: 'Yes', value: true },
-                        { name: 'No, I\'ll add them later', value: false },
+                        { name: 'Yes', value: true, command: `prlt roadmap add-project "${roadmap.id}" --json` },
+                        { name: 'No, I\'ll add them later', value: false, command: '' },
                     ],
-                }]);
+                }], null);
             if (addProjects) {
-                const { selectedProjects } = await inquirer.prompt([{
+                const { selectedProjects } = await this.prompt([{
                         type: 'checkbox',
                         name: 'selectedProjects',
                         message: 'Select projects to include:',
-                        choices: projects.map(p => ({ name: p.name, value: p.id })),
-                    }]);
+                        choices: projects.map(p => ({
+                            name: p.name,
+                            value: p.id,
+                            command: `prlt roadmap add-project "${roadmap.id}" "${p.id}" --json`,
+                        })),
+                    }], null);
                 for (const projectId of selectedProjects) {
                     // eslint-disable-next-line no-await-in-loop -- Sequential updates
                     await this.storage.addProjectToRoadmap(roadmap.id, projectId);
@@ -143,21 +166,4 @@ export default class RoadmapCreate extends PMOCommand {
         this.log(styles.muted(`  prlt roadmap add-project ${roadmap.id}`));
         this.log(styles.muted(`  prlt roadmap generate ${roadmap.id}`));
     }
-    async promptRoadmapData(fields) {
-        const answers = await inquirer.prompt(fields.map(field => ({
-            ...field,
-            validate: field.name === 'name'
-                ? ((input) => input.length > 0 || 'Name is required')
-                : undefined,
-            default: field.name === 'id'
-                ? ((answers) => `roadmap-${slugify(answers.name)}`)
-                : field.default,
-        })));
-        return {
-            name: answers.name,
-            id: answers.id || undefined,
-            description: answers.description || undefined,
-            isDefault: answers.isDefault === true || answers.isDefault === 'true',
-        };
-    }
 }

package/dist/commands/roadmap/delete.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 RoadmapDelete extends PMOCommand {
     static description = 'Delete a roadmap';
     static examples = [
@@ -47,23 +46,17 @@ export default class RoadmapDelete extends PMOCommand {
                 }
                 this.error('No roadmaps found.');
             }
-            if (jsonMode) {
-                const choices = roadmaps.map(r => ({
-                    name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
-                    value: r.id,
-                }));
-                outputPromptAsJson(buildPromptConfig('list', 'id', 'Select roadmap to delete:', choices), createMetadata('roadmap delete', flags));
-                return;
-            }
-            const { selected } = await inquirer.prompt([{
+            const jsonModeConfig = jsonMode ? { flags, commandName: 'roadmap delete' } : null;
+            const { selected } = await this.prompt([{
                     type: 'list',
                     name: 'selected',
                     message: 'Select roadmap to delete:',
                     choices: roadmaps.map(r => ({
                         name: `${r.name}${r.isDefault ? ' (default)' : ''}`,
                         value: r.id,
+                        command: `prlt roadmap delete "${r.id}" --json`,
                     })),
-                }]);
+                }], jsonModeConfig);
             roadmapId = selected;
         }
         const roadmap = await this.storage.getRoadmap(roadmapId);
@@ -87,23 +80,16 @@ export default class RoadmapDelete extends PMOCommand {
         // Confirm deletion
         if (!flags.force) {
             const message = `Delete roadmap "${roadmap.name}"${projects.length > 0 ? ` (contains ${projects.length} project reference${projects.length > 1 ? 's' : ''})` : ''}?`;
-            if (jsonMode) {
-                const confirmChoices = [
-                    { name: 'No, cancel', value: 'false' },
-                    { name: 'Yes, delete', value: 'true' },
-                ];
-                outputPromptAsJson(buildPromptConfig('list', 'confirmed', message, confirmChoices), createMetadata('roadmap delete', flags));
-                return;
-            }
-            const { confirm } = await inquirer.prompt([{
+            const confirmJsonModeConfig = jsonMode ? { flags, commandName: 'roadmap delete' } : null;
+            const { confirm } = await this.prompt([{
                     type: 'list',
                     name: 'confirm',
                     message,
                     choices: [
-                        { name: 'No, cancel', value: false },
-                        { name: 'Yes, delete', value: true },
+                        { name: 'No, cancel', value: false, command: '' },
+                        { name: 'Yes, delete', value: true, command: `prlt roadmap delete "${roadmapId}" --force --json` },
                     ],
-                }]);
+                }], confirmJsonModeConfig);
             if (!confirm) {
                 this.log(styles.muted('Cancelled.'));
                 return;

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

@@ -8,6 +8,7 @@ export default class RoadmapGenerate extends PMOCommand {
     static flags: {
         all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'exclude-done': 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>;
     };