@nemus-cli/nemus 0.2.1

package/dist/commands/migrate.js

@@ -0,0 +1,296 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMigrateCommand = registerMigrateCommand;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const child_process_1 = require("child_process");
+const config_1 = require("../utils/config");
+const workspace_meta_1 = require("../utils/workspace-meta");
+const claude_integration_1 = require("../utils/claude-integration");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+const agent_config_1 = require("../utils/agent-config");
+function registerMigrateCommand(parent) {
+    parent
+        .command('migrate')
+        .description('Migrate all workspaces to latest format (regenerate context files, update metadata)')
+        .option('--dry-run', 'Show what would be changed without making changes')
+        .action(async (opts) => {
+        await handleMigrate(opts);
+    });
+}
+async function handleMigrate(opts) {
+    const dryRun = opts.dryRun ?? false;
+    if (dryRun) {
+        (0, logger_1.logInfo)('Dry run mode - no changes will be made\n');
+    }
+    const workspaces = await (0, workspace_meta_1.listWorkspaces)(false);
+    if (workspaces.length === 0) {
+        (0, logger_1.logInfo)('No workspaces found. Nothing to migrate.');
+        return;
+    }
+    (0, logger_1.logInfo)(`Found ${(0, colors_1.colorize)(String(workspaces.length), 'cyan')} workspaces to migrate\n`);
+    let migrated = 0;
+    let skipped = 0;
+    let errors = 0;
+    for (const ws of workspaces) {
+        const wsPath = ws.path;
+        const metadata = await (0, workspace_meta_1.loadMetadata)(wsPath);
+        if (!metadata) {
+            // No metadata file - reconstruct it by scanning git subdirectories
+            (0, logger_1.logWarning)(`${ws.name}: no metadata found - reconstructing from git repos`);
+            const reconstructed = await reconstructMetadata(ws.name, wsPath);
+            if (!reconstructed) {
+                (0, logger_1.logError)(`  ${ws.name}: could not reconstruct metadata (no git repos found), skipping`);
+                skipped++;
+                continue;
+            }
+            if (!dryRun) {
+                await (0, workspace_meta_1.saveMetadata)(wsPath, reconstructed);
+                (0, logger_1.logSuccess)(`  ${(0, colors_1.colorize)(ws.name, 'cyan')}: metadata created (${reconstructed.repositories.length} repos detected)`);
+            }
+            else {
+                (0, logger_1.logInfo)(`  ${(0, colors_1.colorize)(ws.name, 'cyan')}: would create metadata (${reconstructed.repositories.length} repos detected)`);
+            }
+            // Regenerate context files using the reconstructed metadata.
+            const meta = reconstructed;
+            if (!dryRun) {
+                const repos = meta.repositories
+                    .filter(r => r.status === 'success')
+                    .map(r => ({ name: r.name, description: '', url: r.cloneUrl, owner: { login: r.owner }, sshUrl: r.cloneUrl }));
+                try {
+                    await (0, claude_integration_1.generateClaudeContext)(wsPath, ws.name, repos, meta);
+                }
+                catch { /* context gen is best-effort */ }
+            }
+            migrated++;
+            continue;
+        }
+        try {
+            const dirNames = metadata.repositories
+                .filter(r => r.status === 'success')
+                .map(r => r.directoryName);
+            const contextFiles = (0, agent_config_1.getContextFileNames)();
+            // Read all existing context files first — before any writes.
+            // If any file is missing we must fall back to full regeneration;
+            // we determine this BEFORE touching anything so we never mix
+            // surgical patches with a subsequent full overwrite.
+            const existingContents = new Map();
+            let needsFullRegen = false;
+            for (const fileName of contextFiles) {
+                try {
+                    existingContents.set(fileName, await fs.readFile(path.join(wsPath, fileName), 'utf-8'));
+                }
+                catch {
+                    needsFullRegen = true;
+                    break;
+                }
+            }
+            // Build the per-repo section (needs disk access; do once for both paths).
+            const perRepoSection = await (0, claude_integration_1.buildPerRepoContextSection)(wsPath, dirNames);
+            const repoCount = perRepoSection ? (perRepoSection.match(/^###/gm) || []).length : 0;
+            if (dryRun) {
+                if (needsFullRegen) {
+                    (0, logger_1.logInfo)(`  ${(0, colors_1.colorize)(ws.name, 'cyan')}: would regenerate context files from scratch (context file missing)`);
+                }
+                else if (repoCount > 0) {
+                    (0, logger_1.logInfo)(`  ${(0, colors_1.colorize)(ws.name, 'cyan')}: would embed per-repo context from ${repoCount} location(s) into ${contextFiles.join(', ')}`);
+                }
+                else {
+                    (0, logger_1.logInfo)(`  ${(0, colors_1.colorize)(ws.name, 'cyan')}: would update ${contextFiles.join(', ')} (no per-repo context files found — any existing section removed)`);
+                }
+                migrated++;
+                continue;
+            }
+            // Ensure lastModified is set
+            if (!metadata.lastModified) {
+                metadata.lastModified = new Date().toISOString();
+                await (0, workspace_meta_1.saveMetadata)(wsPath, metadata);
+            }
+            if (needsFullRegen) {
+                // One or more context files are missing — regenerate all from scratch.
+                const repos = metadata.repositories
+                    .filter(r => r.status === 'success')
+                    .map(r => ({
+                    name: r.name, description: '', url: r.cloneUrl,
+                    owner: { login: r.owner }, sshUrl: r.cloneUrl,
+                }));
+                await (0, claude_integration_1.generateClaudeContext)(wsPath, ws.name, repos, metadata);
+            }
+            else {
+                // All context files exist — patch only the per-repo section in each.
+                for (const [fileName, existing] of existingContents) {
+                    const updated = upsertPerRepoSection(existing, perRepoSection);
+                    if (updated !== existing) {
+                        await fs.writeFile(path.join(wsPath, fileName), updated, 'utf-8');
+                    }
+                }
+            }
+            const detail = needsFullRegen
+                ? ' (regenerated from scratch)'
+                : repoCount > 0
+                    ? ` (embedded per-repo context from ${repoCount} location(s))`
+                    : ' (no per-repo context files found)';
+            (0, logger_1.logSuccess)(`  ${(0, colors_1.colorize)(ws.name, 'cyan')}: migrated${detail}`);
+            migrated++;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            (0, logger_1.logError)(`  ${ws.name}: ${msg}`);
+            errors++;
+        }
+    }
+    console.log('');
+    (0, logger_1.logInfo)(dryRun ? 'Dry run complete:' : 'Migration complete:');
+    console.log(`  ${(0, colors_1.colorize)(String(migrated), 'green')} ${dryRun ? 'would migrate' : 'migrated'}`);
+    if (skipped > 0)
+        console.log(`  ${(0, colors_1.colorize)(String(skipped), 'yellow')} skipped`);
+    if (errors > 0)
+        console.log(`  ${(0, colors_1.colorize)(String(errors), 'red')} errors`);
+}
+/**
+ * Reconstruct a WorkspaceMetadata object for a workspace that has no metadata
+ * file by scanning subdirectories for git repositories and reading their
+ * remote origin URLs.
+ *
+ * Returns null if no git repos are found in the workspace directory.
+ */
+async function reconstructMetadata(workspaceName, workspacePath) {
+    let entries;
+    try {
+        entries = await fs.readdir(workspacePath);
+    }
+    catch {
+        return null;
+    }
+    const repositories = [];
+    for (const entry of entries) {
+        const repoPath = path.join(workspacePath, entry);
+        try {
+            const stat = await fs.stat(repoPath);
+            if (!stat.isDirectory())
+                continue;
+            // Check it's a git repo
+            await fs.access(path.join(repoPath, '.git'));
+            // Get the remote origin URL
+            let cloneUrl = '';
+            let owner = (0, config_1.getUserConfig)().githubOrg || 'your-org';
+            try {
+                cloneUrl = (0, child_process_1.execSync)('git remote get-url origin', {
+                    cwd: repoPath, stdio: 'pipe', encoding: 'utf-8',
+                }).trim();
+                // Extract owner from SSH URL: git@github.com:owner/repo.git
+                const sshMatch = cloneUrl.match(/github\.com[:/]([^/]+)\//);
+                if (sshMatch)
+                    owner = sshMatch[1];
+            }
+            catch { /* no remote - leave blank */ }
+            // Derive the canonical repo name from the remote URL, falling back
+            // to the directory name.
+            let repoName = entry;
+            try {
+                const urlMatch = cloneUrl.match(/\/([^/]+?)\.git$/) ||
+                    cloneUrl.match(/\/([^/]+)$/);
+                if (urlMatch)
+                    repoName = urlMatch[1];
+            }
+            catch { /* use directory name */ }
+            repositories.push({
+                name: repoName,
+                directoryName: entry,
+                owner,
+                clonedAt: new Date().toISOString(),
+                cloneUrl,
+                status: 'success',
+            });
+        }
+        catch { /* not accessible or not a git repo - skip */ }
+    }
+    if (repositories.length === 0)
+        return null;
+    return {
+        workspaceName,
+        createdAt: new Date().toISOString(),
+        lastModified: new Date().toISOString(),
+        repositories,
+    };
+}
+/**
+ * Insert or replace the '## Per-Repository Context' section in an existing
+ * workspace context file, leaving everything else (user notes, etc.) intact.
+ *
+ * Insertion order (preferred first — we want the section as early as
+ * possible so the LLM weights it heavily):
+ *   1. Before '## Common Workflows'   — the new canonical position
+ *   2. Before '## Workspace Management' (older layouts)
+ *   3. Before '## AI Agent Rules'      (older layouts)
+ *   4. Before '## Tips for Working'    (older layouts)
+ *   5. Before '## Notes'               (legacy fallback)
+ *   6. Before '## Saved Context'       (legacy fallback)
+ *   7. Appended at the end             (last resort)
+ *
+ * If `newSection` is null the existing section (if any) is removed so that
+ * a workspace that previously had per-repo context but no longer does gets
+ * cleaned up.
+ */
+function upsertPerRepoSection(content, newSection) {
+    // Match the section *including* its leading blank line(s) so removal
+    // leaves a clean join with no leftover blank lines. No 'm' flag so '$'
+    // only matches the true end-of-string.
+    const sectionRegex = /\n{1,2}## Per-Repository Context\b[\s\S]*?(?=\n## |\n#{1,2} |$)/;
+    // Only trimEnd() the very end of the file — never touch the body.
+    const base = content.replace(sectionRegex, '').trimEnd();
+    if (!newSection)
+        return base + '\n'; // section removed, nothing to add back
+    const block = `\n\n${newSection.trim()}\n`;
+    // Try anchors in order of preference — earliest first so per-repo rules
+    // are read by the LLM before generic boilerplate.
+    const anchors = [
+        '\n## Common Workflows',
+        '\n## Workspace Management',
+        '\n## AI Agent Rules',
+        '\n## Tips for Working',
+        '\n## Notes',
+        '\n## Saved Context',
+    ];
+    for (const anchor of anchors) {
+        if (base.includes(anchor)) {
+            return base.replace(anchor, `${block}${anchor}`);
+        }
+    }
+    // Append (last resort)
+    return base + block;
+}

package/dist/commands/remove-repo.js

@@ -0,0 +1,217 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRemoveRepoCommand = registerRemoveRepoCommand;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const config_1 = require("../utils/config");
+const workspace_meta_1 = require("../utils/workspace-meta");
+const claude_integration_1 = require("../utils/claude-integration");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+const inquirer_1 = __importDefault(require("inquirer"));
+const inquirer_autocomplete_prompt_1 = __importDefault(require("inquirer-autocomplete-prompt"));
+const fuzzy = __importStar(require("fuzzy"));
+const command_helpers_1 = require("../utils/command-helpers");
+inquirer_1.default.registerPrompt('autocomplete', inquirer_autocomplete_prompt_1.default);
+function registerRemoveRepoCommand(parent) {
+    parent
+        .command('remove-repo')
+        .alias('rr')
+        .description('Remove a repo from a workspace')
+        .option('-w, --workspace <name>', 'Workspace name')
+        .option('-r, --repos <repos>', 'Comma-separated repository directory names')
+        .action(async (opts, cmd) => {
+        const globalOpts = (0, command_helpers_1.getGlobalOpts)(cmd);
+        await handleRemoveRepo({ ...opts, ...globalOpts });
+    });
+}
+async function handleRemoveRepo(opts) {
+    console.log('\n' + '='.repeat(60));
+    console.log((0, colors_1.colorize)('Remove Repository Instances', 'bright'));
+    console.log('='.repeat(60) + '\n');
+    try {
+        (0, logger_1.logStep)(1, 4, 'Select workspace...');
+        const workspaceName = await (0, command_helpers_1.resolveWorkspace)(opts.workspace);
+        const workspacePath = path.join(config_1.WORKSPACES_DIR, workspaceName);
+        (0, logger_1.logInfo)(`Selected workspace: ${(0, colors_1.colorize)(workspaceName, 'cyan')}`);
+        (0, logger_1.logStep)(2, 4, 'Loading repository instances...');
+        const metadata = await (0, workspace_meta_1.loadMetadata)(workspacePath);
+        const successRepos = metadata?.repositories.filter(r => r.status === 'success') ?? [];
+        const entries = await fs.readdir(workspacePath, { withFileTypes: true });
+        const diskDirs = entries
+            .filter(e => e.isDirectory() && !e.name.startsWith('.'))
+            .map(e => e.name);
+        const metaDirNames = new Set(successRepos.map(r => r.directoryName));
+        const repoEntries = [];
+        for (const repo of successRepos) {
+            repoEntries.push({
+                displayName: repo.directoryName !== repo.name
+                    ? `${repo.directoryName} (${repo.name})`
+                    : repo.directoryName,
+                dirName: repo.directoryName,
+            });
+        }
+        for (const dir of diskDirs) {
+            if (!metaDirNames.has(dir)) {
+                repoEntries.push({ displayName: `${dir} (untracked)`, dirName: dir });
+            }
+        }
+        if (repoEntries.length === 0) {
+            (0, logger_1.logInfo)('No repositories found in this workspace.');
+            if (opts.yes) {
+                await fs.rm(workspacePath, { recursive: true, force: true });
+                (0, logger_1.logSuccess)(`Workspace "${workspaceName}" deleted.`);
+            }
+            else {
+                const { deleteWorkspace } = await inquirer_1.default.prompt([{
+                        type: 'confirm', name: 'deleteWorkspace',
+                        message: `Delete the entire workspace folder "${workspaceName}"?`, default: false,
+                    }]);
+                if (deleteWorkspace) {
+                    await fs.rm(workspacePath, { recursive: true, force: true });
+                    (0, logger_1.logSuccess)(`Workspace "${workspaceName}" deleted.`);
+                }
+                else {
+                    (0, logger_1.logInfo)('No action taken.');
+                }
+            }
+            process.exit(0);
+        }
+        (0, logger_1.logStep)(3, 4, 'Select instances to remove...');
+        let selectedDirs;
+        if (opts.repos) {
+            selectedDirs = (0, command_helpers_1.parseList)(opts.repos);
+            const unknownDirs = selectedDirs.filter(d => !repoEntries.some(e => e.dirName === d));
+            if (unknownDirs.length > 0) {
+                (0, logger_1.logError)(`Directories not found in workspace: ${unknownDirs.join(', ')}`);
+                process.exit(1);
+            }
+        }
+        else {
+            console.log('\n' + (0, colors_1.colorize)('Repository Selection', 'bright'));
+            console.log('Type to search repositories. Use arrow keys to navigate, Enter to select.');
+            console.log('Type "done" when finished selecting.\n');
+            selectedDirs = [];
+            while (true) {
+                const available = repoEntries.filter(e => !selectedDirs.includes(e.dirName));
+                if (available.length === 0) {
+                    console.log((0, colors_1.colorize)('All repositories selected.', 'yellow'));
+                    break;
+                }
+                try {
+                    const { repoDir } = await inquirer_1.default.prompt([{
+                            type: 'autocomplete', name: 'repoDir',
+                            message: `Search and select repository (${(0, colors_1.colorize)(String(selectedDirs.length), 'cyan')} selected):`,
+                            source: async (_answersSoFar, input) => {
+                                const searchInput = input || '';
+                                const doneOption = { name: (0, colors_1.colorize)('done - Finish selection', 'green'), value: 'done' };
+                                if (!searchInput || searchInput.toLowerCase().startsWith('done')) {
+                                    return [doneOption, ...available.map(e => ({ name: e.displayName, value: e.dirName }))];
+                                }
+                                const results = fuzzy.filter(searchInput, available, { extract: (e) => e.displayName });
+                                return [doneOption, ...results.map(result => ({ name: result.original.displayName, value: result.original.dirName }))];
+                            },
+                            pageSize: 16,
+                        }]);
+                    if (repoDir === 'done') {
+                        if (selectedDirs.length === 0) {
+                            console.log((0, colors_1.colorize)('\nYou must select at least one repository\n', 'yellow'));
+                            continue;
+                        }
+                        break;
+                    }
+                    selectedDirs.push(repoDir);
+                    const entry = repoEntries.find(e => e.dirName === repoDir);
+                    console.log((0, colors_1.colorize)(`Added: ${entry?.displayName || repoDir}`, 'green'));
+                }
+                catch {
+                    console.log('\n');
+                    process.exit(0);
+                }
+            }
+        }
+        console.log(`\n${(0, colors_1.colorize)(`Selected ${selectedDirs.length} repository instance${selectedDirs.length === 1 ? '' : 's'}:`, 'cyan')}`);
+        selectedDirs.forEach(dir => console.log(`  - ${dir}`));
+        console.log('');
+        if (!opts.yes) {
+            const { confirm } = await inquirer_1.default.prompt([{
+                    type: 'confirm', name: 'confirm',
+                    message: `Remove ${selectedDirs.length} instance(s)? This will delete the directories.`, default: false,
+                }]);
+            if (!confirm) {
+                (0, logger_1.logInfo)('Removal cancelled');
+                process.exit(0);
+            }
+        }
+        (0, logger_1.logStep)(4, 4, 'Removing instances...');
+        for (const dirName of selectedDirs) {
+            const dirPath = path.join(workspacePath, dirName);
+            try {
+                await fs.rm(dirPath, { recursive: true, force: true });
+                (0, logger_1.logSuccess)(`Removed: ${dirName}`);
+            }
+            catch (error) {
+                (0, logger_1.logError)(`Failed to remove ${dirName}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        const removedSet = new Set(selectedDirs);
+        if (metadata) {
+            metadata.repositories = metadata.repositories.filter(r => !removedSet.has(r.directoryName));
+            await (0, workspace_meta_1.saveMetadata)(workspacePath, metadata);
+            const remainingRepos = metadata.repositories
+                .filter(r => r.status === 'success')
+                .map(r => ({
+                name: r.name, url: '', sshUrl: r.cloneUrl,
+                owner: { login: r.owner }, description: '', isPrivate: true,
+            }));
+            if (remainingRepos.length > 0) {
+                await (0, claude_integration_1.generateClaudeContext)(workspacePath, workspaceName, remainingRepos, metadata);
+            }
+            console.log(`\nWorkspace now has ${(0, colors_1.colorize)(String(metadata.repositories.length), 'cyan')} repositories\n`);
+        }
+        (0, logger_1.logSuccess)('Repository instances removed successfully!');
+    }
+    catch (error) {
+        (0, logger_1.logError)('Failed to remove repository instances');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/report-bug.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerReportBugCommand = registerReportBugCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+const bug_report_1 = require("../utils/bug-report");
+function getVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', '..', 'package.json'), 'utf-8'));
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+function registerReportBugCommand(parent) {
+    parent
+        .command('report-bug')
+        .description('File the last error (or a custom message) as a GitHub issue')
+        .option('-m, --message <message>', 'Report a custom message instead of the last captured error')
+        .option('-f, --force', 'Report even if the error looks environmental (network/auth)')
+        .action(async (opts) => {
+        await handleReportBug(opts);
+    });
+}
+async function handleReportBug(opts) {
+    let captured;
+    if (opts.message) {
+        captured = {
+            command: 'w report-bug (manual)',
+            message: opts.message,
+            timestamp: new Date().toISOString(),
+            version: getVersion(),
+        };
+    }
+    else {
+        captured = (0, bug_report_1.readLastError)();
+        if (!captured) {
+            (0, logger_1.logError)('No recent error to report.');
+            (0, logger_1.logInfo)('Run a command that fails first, or use: w report-bug -m "describe the bug"');
+            process.exit(1);
+            return;
+        }
+        // Show which error we're about to report (with its age). Some failures
+        // — notably `nemus -- <prompt>` — exit without updating last-error.json, so
+        // the most recent capture could be an older crash. Surfacing the
+        // timestamp lets the user catch a stale report before filing.
+        const ageMs = Date.now() - new Date(captured.timestamp).getTime();
+        const ageMin = Math.floor(ageMs / 60000);
+        const when = Number.isFinite(ageMin)
+            ? (ageMin < 1 ? 'just now' : `${ageMin} min ago`)
+            : 'unknown time';
+        (0, logger_1.logInfo)(`Last captured error (${when}): ${(0, colors_1.colorize)(captured.command, 'cyan')}`);
+        (0, logger_1.logInfo)(`  ${captured.message.split('\n')[0].slice(0, 100)}`);
+        if (ageMin >= 10) {
+            (0, logger_1.logWarning)(`This error is ${ageMin} min old — make sure it's the one you mean to report.`);
+            (0, logger_1.logInfo)('Tip: pass -m "..." to report a specific message instead.');
+        }
+    }
+    (0, logger_1.logInfo)(`Reporting to ${(0, colors_1.colorize)(bug_report_1.BUG_REPORT_REPO, 'cyan')}...`);
+    const result = (0, bug_report_1.reportBug)(captured, getVersion(), { force: opts.force });
+    switch (result.status) {
+        case 'created':
+            (0, logger_1.logSuccess)(`Bug issue created: ${(0, colors_1.colorize)(result.url, 'cyan')}`);
+            break;
+        case 'duplicate':
+            (0, logger_1.logInfo)(`This error was already reported: ${(0, colors_1.colorize)(result.url, 'cyan')}`);
+            (0, logger_1.logInfo)('Subscribe there for updates — no duplicate filed.');
+            break;
+        case 'skipped':
+            (0, logger_1.logWarning)(result.reason || 'Skipped.');
+            break;
+        case 'failed':
+            (0, logger_1.logError)(result.reason || 'Failed to file the bug report.');
+            process.exit(1);
+    }
+}