@proletariat/cli 0.3.24 → 0.3.25

package/dist/commands/feedback/submit.js

@@ -0,0 +1,220 @@
+import { Command, Flags } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import * as os from 'node:os';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { styles } from '../../lib/styles.js';
+import { isGHInstalled, isGHAuthenticated } from '../../lib/pr/index.js';
+import { isMachineOutput, outputSuccessAsJson, outputErrorAsJson, outputPromptAsJson, buildPromptConfig, createMetadata, } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+// Target repository for feedback issues
+const FEEDBACK_REPO = 'chrismcdermut/proletariat';
+// Category to GitHub label mapping
+const CATEGORY_LABELS = {
+    bug: 'bug',
+    feature: 'enhancement',
+    general: 'feedback',
+};
+export default class FeedbackSubmit extends Command {
+    static description = 'Submit feedback, bug reports, or feature requests to GitHub Issues';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --title "Bug in CLI" --body "Description here" --category bug',
+        '<%= config.bin %> <%= command.id %> --json',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+        title: Flags.string({
+            char: 't',
+            description: 'Issue title (one-liner) [required for non-interactive]',
+        }),
+        body: Flags.string({
+            char: 'b',
+            description: 'Issue description [required for non-interactive]',
+        }),
+        category: Flags.string({
+            char: 'c',
+            description: 'Feedback category',
+            options: ['bug', 'feature', 'general'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(FeedbackSubmit);
+        const jsonMode = isMachineOutput(flags);
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('feedback submit', flags));
+            }
+            this.error(message);
+        };
+        // Check if gh CLI is installed
+        if (!isGHInstalled()) {
+            return handleError('GH_NOT_INSTALLED', 'GitHub CLI (gh) is not installed. Install it with: brew install gh');
+        }
+        // Check if gh is authenticated
+        if (!isGHAuthenticated()) {
+            return handleError('GH_NOT_AUTHENTICATED', 'GitHub CLI is not authenticated. Run: gh auth login');
+        }
+        // Collect category
+        let category = flags.category;
+        if (!category) {
+            const categoryChoices = [
+                { name: 'Bug report', value: 'bug' },
+                { name: 'Feature request', value: 'feature' },
+                { name: 'General feedback', value: 'general' },
+            ];
+            const categoryMessage = 'What type of feedback would you like to submit?';
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('list', 'category', categoryMessage, categoryChoices), createMetadata('feedback submit', flags));
+                return;
+            }
+            const { selectedCategory } = await inquirer.prompt([{
+                    type: 'list',
+                    name: 'selectedCategory',
+                    message: categoryMessage,
+                    choices: categoryChoices,
+                }]);
+            category = selectedCategory;
+        }
+        // Collect title
+        let title = flags.title;
+        if (!title) {
+            const titleMessage = 'Enter a brief title for your feedback:';
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('input', 'title', titleMessage), createMetadata('feedback submit', { ...flags, category }));
+                return;
+            }
+            const { inputTitle } = await inquirer.prompt([{
+                    type: 'input',
+                    name: 'inputTitle',
+                    message: titleMessage,
+                    validate: (input) => {
+                        if (!input.trim()) {
+                            return 'Title is required';
+                        }
+                        if (input.length > 200) {
+                            return 'Title must be less than 200 characters';
+                        }
+                        return true;
+                    },
+                }]);
+            title = inputTitle;
+        }
+        // Collect body/description
+        let body = flags.body;
+        if (!body) {
+            const bodyMessage = 'Describe your feedback in detail:';
+            if (jsonMode) {
+                outputPromptAsJson(buildPromptConfig('editor', 'body', bodyMessage), createMetadata('feedback submit', { ...flags, category, title }));
+                return;
+            }
+            const { inputBody } = await inquirer.prompt([{
+                    type: 'editor',
+                    name: 'inputBody',
+                    message: bodyMessage,
+                    validate: (input) => {
+                        if (!input.trim()) {
+                            return 'Description is required';
+                        }
+                        return true;
+                    },
+                }]);
+            body = inputBody;
+        }
+        // Build diagnostics section
+        const diagnostics = this.collectDiagnostics();
+        // Build full issue body with diagnostics
+        const fullBody = `${body}\n\n---\n\n## Diagnostics\n\n${diagnostics}`;
+        // Get label for category
+        const label = CATEGORY_LABELS[category] || 'feedback';
+        // Create the GitHub issue
+        if (!jsonMode) {
+            this.log(styles.muted('\nCreating issue on GitHub...\n'));
+        }
+        // Escape title for shell
+        const escapedTitle = title.replace(/"/g, '\\"');
+        let usedLabel = label;
+        let result;
+        try {
+            // Try with label first
+            result = execSync(`gh issue create --repo "${FEEDBACK_REPO}" --title "${escapedTitle}" --body-file - --label "${label}"`, {
+                encoding: 'utf-8',
+                input: fullBody,
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch (labelError) {
+            // If label doesn't exist, try without label
+            const labelErrorMessage = labelError instanceof Error ? labelError.message : '';
+            if (labelErrorMessage.includes('not found') && labelErrorMessage.includes('label')) {
+                try {
+                    usedLabel = null;
+                    result = execSync(`gh issue create --repo "${FEEDBACK_REPO}" --title "${escapedTitle}" --body-file -`, {
+                        encoding: 'utf-8',
+                        input: fullBody,
+                        stdio: ['pipe', 'pipe', 'pipe'],
+                    }).trim();
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error creating issue';
+                    return handleError('ISSUE_CREATE_FAILED', `Failed to create issue: ${errorMessage}`);
+                }
+            }
+            else {
+                const errorMessage = labelError instanceof Error ? labelError.message : 'Unknown error creating issue';
+                return handleError('ISSUE_CREATE_FAILED', `Failed to create issue: ${errorMessage}`);
+            }
+        }
+        // Parse issue URL from result
+        const issueUrl = result;
+        const issueMatch = issueUrl.match(/\/issues\/(\d+)/);
+        const issueNumber = issueMatch ? parseInt(issueMatch[1], 10) : undefined;
+        if (jsonMode) {
+            outputSuccessAsJson({
+                issueUrl,
+                issueNumber,
+                title: title,
+                category: category,
+                label: usedLabel,
+                repository: FEEDBACK_REPO,
+            }, createMetadata('feedback submit', flags));
+        }
+        this.log(chalk.green('  ✓ Issue created successfully!\n'));
+        this.log(`${styles.header('Issue URL:')} ${chalk.cyan(issueUrl)}`);
+        if (issueNumber) {
+            this.log(`${styles.header('Issue #:')}   ${issueNumber}`);
+        }
+        this.log(`${styles.header('Category:')} ${category}`);
+        if (usedLabel) {
+            this.log(`${styles.header('Label:')}    ${usedLabel}\n`);
+        }
+        else {
+            this.log(styles.muted(`(Label '${label}' not found in repository)\n`));
+        }
+        this.log(styles.muted('Thank you for your feedback!'));
+    }
+    /**
+     * Collect diagnostic information to include in the issue
+     */
+    collectDiagnostics() {
+        const lines = [];
+        // CLI version
+        lines.push(`- **CLI Version:** ${this.config.version}`);
+        // Node version
+        lines.push(`- **Node Version:** ${process.version}`);
+        // OS info
+        lines.push(`- **OS:** ${process.platform}`);
+        lines.push(`- **OS Version:** ${os.release()}`);
+        // Try to get workspace name if available
+        try {
+            const cwd = process.cwd();
+            const workspaceName = cwd.split('/').pop() || 'unknown';
+            lines.push(`- **Working Directory:** ${workspaceName}`);
+        }
+        catch {
+            // Ignore errors getting workspace name
+        }
+        return lines.join('\n');
+    }
+}

package/dist/commands/feedback/view.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class FeedbackView extends Command {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        number: import("@oclif/core/interfaces").Arg<number, {
+            max?: number;
+            min?: number;
+        }>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/feedback/view.js

@@ -0,0 +1,109 @@
+import { Command, Args } from '@oclif/core';
+import { execSync } from 'node:child_process';
+import chalk from 'chalk';
+import { styles } from '../../lib/styles.js';
+import { isGHInstalled, isGHAuthenticated } from '../../lib/pr/index.js';
+import { isMachineOutput, outputSuccessAsJson, outputErrorAsJson, createMetadata, } from '../../lib/prompt-json.js';
+import { machineOutputFlags } from '../../lib/pmo/index.js';
+// Target repository for feedback issues
+const FEEDBACK_REPO = 'chrismcdermut/proletariat';
+export default class FeedbackView extends Command {
+    static description = 'View details of a specific feedback issue';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> 123',
+        '<%= config.bin %> <%= command.id %> 123 --json',
+    ];
+    static flags = {
+        ...machineOutputFlags,
+    };
+    static args = {
+        number: Args.integer({
+            description: 'Issue number to view',
+            required: true,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(FeedbackView);
+        const jsonMode = isMachineOutput(flags);
+        const issueNumber = args.number;
+        // Helper to handle errors in JSON mode
+        const handleError = (code, message) => {
+            if (jsonMode) {
+                outputErrorAsJson(code, message, createMetadata('feedback view', flags));
+            }
+            this.error(message);
+        };
+        // Check if gh CLI is installed
+        if (!isGHInstalled()) {
+            return handleError('GH_NOT_INSTALLED', 'GitHub CLI (gh) is not installed. Install it with: brew install gh');
+        }
+        // Check if gh is authenticated
+        if (!isGHAuthenticated()) {
+            return handleError('GH_NOT_AUTHENTICATED', 'GitHub CLI is not authenticated. Run: gh auth login');
+        }
+        try {
+            // Get issue details
+            const result = execSync(`gh issue view ${issueNumber} --repo "${FEEDBACK_REPO}" --json number,title,body,state,labels,createdAt,updatedAt,author,comments`, {
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+            const issue = JSON.parse(result);
+            if (jsonMode) {
+                outputSuccessAsJson({
+                    number: issue.number,
+                    title: issue.title,
+                    body: issue.body,
+                    state: issue.state,
+                    labels: issue.labels.map(l => l.name),
+                    createdAt: issue.createdAt,
+                    updatedAt: issue.updatedAt,
+                    author: issue.author.login,
+                    comments: issue.comments.map(c => ({
+                        author: c.author.login,
+                        body: c.body,
+                        createdAt: c.createdAt,
+                    })),
+                    url: `https://github.com/${FEEDBACK_REPO}/issues/${issue.number}`,
+                    repository: FEEDBACK_REPO,
+                }, createMetadata('feedback view', flags));
+            }
+            // Display issue in human-friendly format
+            const stateIcon = issue.state === 'OPEN' ? chalk.green('OPEN') : chalk.red('CLOSED');
+            const labels = issue.labels.map(l => chalk.cyan(`[${l.name}]`)).join(' ');
+            const createdDate = new Date(issue.createdAt).toLocaleString();
+            const updatedDate = new Date(issue.updatedAt).toLocaleString();
+            this.log(`\n${styles.header('Issue #')}${chalk.bold(String(issue.number))} ${stateIcon}\n`);
+            this.log(`${styles.header('Title:')}   ${issue.title}`);
+            this.log(`${styles.header('Author:')}  ${issue.author.login}`);
+            this.log(`${styles.header('Labels:')}  ${labels || styles.muted('none')}`);
+            this.log(`${styles.header('Created:')} ${createdDate}`);
+            this.log(`${styles.header('Updated:')} ${updatedDate}`);
+            this.log(`${styles.header('URL:')}     ${chalk.cyan(`https://github.com/${FEEDBACK_REPO}/issues/${issue.number}`)}`);
+            if (issue.body) {
+                this.log(`\n${styles.header('Description:')}`);
+                this.log(styles.muted('─'.repeat(50)));
+                this.log(issue.body);
+                this.log(styles.muted('─'.repeat(50)));
+            }
+            if (issue.comments && issue.comments.length > 0) {
+                this.log(`\n${styles.header('Comments:')} (${issue.comments.length})`);
+                this.log(styles.muted('─'.repeat(50)));
+                for (const comment of issue.comments) {
+                    const commentDate = new Date(comment.createdAt).toLocaleString();
+                    this.log(`\n${chalk.bold(comment.author.login)} ${styles.muted(`on ${commentDate}`)}`);
+                    this.log(comment.body);
+                }
+                this.log(styles.muted('─'.repeat(50)));
+            }
+            this.log('');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error viewing issue';
+            // Check if it's a "not found" error
+            if (errorMessage.includes('not found') || errorMessage.includes('Could not resolve')) {
+                return handleError('ISSUE_NOT_FOUND', `Issue #${issueNumber} not found in ${FEEDBACK_REPO}`);
+            }
+            return handleError('ISSUE_VIEW_FAILED', `Failed to view issue: ${errorMessage}`);
+        }
+    }
+}

package/dist/commands/gh/index.js

@@ -32,6 +32,7 @@ export default class GH extends Command {
                 { name: 'Check status', value: 'status', command: 'prlt gh status --json' },
                 { name: 'Login to GitHub', value: 'login', command: 'prlt gh login --json' },
                 { name: 'Show GH_TOKEN setup', value: 'token', command: 'prlt gh token --json' },
+                { name: 'Create GitHub repository', value: 'repo-create', command: 'prlt repo create --json' },
             ],
             skipAutoCommand: true, // Use our custom commands above
         });
@@ -48,6 +49,9 @@ export default class GH extends Command {
             case 'token':
                 await this.config.runCommand('gh token');
                 break;
+            case 'repo-create':
+                await this.config.runCommand('repo create');
+                break;
         }
     }
 }

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'));
+    }
+}