@nemus-cli/nemus 0.2.1

package/dist/commands/configure.js

@@ -0,0 +1,231 @@
+"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.registerConfigureCommand = registerConfigureCommand;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const config_1 = require("../utils/config");
+const cache_1 = require("../utils/cache");
+const logger_1 = require("../utils/logger");
+const colors_1 = require("../utils/colors");
+function registerConfigureCommand(parent) {
+    parent
+        .command('configure')
+        .alias('cfg')
+        .description('Configure workspace manager settings')
+        .action(async () => {
+        await handleConfigure();
+    });
+}
+async function handleConfigure() {
+    console.log('\n' + '='.repeat(60));
+    console.log((0, colors_1.colorize)('Workspace Manager Configuration', 'bright'));
+    console.log('='.repeat(60) + '\n');
+    const current = (0, config_1.getUserConfig)();
+    console.log('Current settings:');
+    console.log(`  Workspaces directory:    ${(0, colors_1.colorize)(current.workspacesDir, 'cyan')}`);
+    console.log(`  GitHub organization:     ${(0, colors_1.colorize)(current.githubOrg, 'cyan')}`);
+    console.log(`  Clone protocol:          ${(0, colors_1.colorize)(current.cloneProtocol, 'cyan')}`);
+    console.log(`  Auto-launch agent:       ${current.autoLaunchClaude ? (0, colors_1.colorize)('Enabled', 'green') : (0, colors_1.colorize)('Disabled', 'red')}`);
+    console.log(`  Generate context file:   ${current.generateClaudeContext ? (0, colors_1.colorize)('Enabled', 'green') : (0, colors_1.colorize)('Disabled', 'red')}`);
+    console.log(`  MCP server:              ${current.installMcp ? (0, colors_1.colorize)('Enabled', 'green') : (0, colors_1.colorize)('Disabled', 'red')}`);
+    console.log(`  AI Agent:                ${(0, colors_1.colorize)(current.aiAgent, 'cyan')}`);
+    console.log(`  Primary agent:           ${(0, colors_1.colorize)(current.primaryAgent, 'cyan')}`);
+    console.log(`  Pi workspace widget:     ${current.piWorkspaceInputStatus !== false ? (0, colors_1.colorize)('Enabled', 'green') : (0, colors_1.colorize)('Disabled', 'red')}`);
+    console.log(`  Claude workspace table:  ${current.claudeWorkspaceStatusLine !== false ? (0, colors_1.colorize)('Enabled', 'green') : (0, colors_1.colorize)('Disabled', 'red')}`);
+    console.log('');
+    try {
+        const answers = await inquirer_1.default.prompt([
+            { type: 'input', name: 'workspacesDir', message: 'Workspaces directory:', default: current.workspacesDir, validate: (val) => val.trim().length > 0 || 'Directory path is required' },
+            { type: 'input', name: 'githubOrg', message: 'GitHub organization:', default: current.githubOrg, validate: (val) => /^[a-zA-Z0-9_-]+$/.test(val.trim()) || 'Must be a valid GitHub org name' },
+            { type: 'list', name: 'cloneProtocol', message: 'Clone protocol:', choices: [{ name: 'SSH  (git@github.com:...)', value: 'ssh' }, { name: 'HTTPS (https://github.com/...)', value: 'https' }], default: current.cloneProtocol },
+            { type: 'confirm', name: 'autoLaunchClaude', message: 'Auto-launch AI agent after workspace creation?', default: current.autoLaunchClaude },
+            { type: 'confirm', name: 'generateClaudeContext', message: 'Generate context file in workspaces?', default: current.generateClaudeContext },
+            { type: 'confirm', name: 'installMcp', message: 'Install MCP server (Claude Code only)?', default: current.installMcp },
+            { type: 'list', name: 'aiAgent', message: 'AI Agent(s) to integrate with:', choices: [
+                    { name: 'Auto-detect (recommended)', value: 'auto' },
+                    { name: 'Claude Code only', value: 'claude' },
+                    { name: 'Pi only', value: 'pi' },
+                    { name: 'OpenCode only', value: 'opencode' },
+                    { name: 'All available', value: 'both' },
+                ], default: current.aiAgent },
+            // Only ask about primary agent when aiAgent is 'both' or 'auto'
+            // (when specific agent chosen, primary is implicitly that agent)
+            { type: 'list', name: 'primaryAgent', message: 'Primary agent (used for launching):', choices: [
+                    { name: 'Auto-detect (first available)', value: 'auto' },
+                    { name: 'Claude Code', value: 'claude' },
+                    { name: 'Pi', value: 'pi' },
+                    { name: 'OpenCode', value: 'opencode' },
+                ], default: current.primaryAgent, when: (ans) => ans.aiAgent === 'both' || ans.aiAgent === 'auto' },
+            { type: 'confirm', name: 'piWorkspaceInputStatus',
+                message: 'Show workspace status widget in Pi input area (branch, PRs, CI)?',
+                default: current.piWorkspaceInputStatus !== false,
+                when: (ans) => ans.aiAgent === 'pi' || ans.aiAgent === 'both' || ans.aiAgent === 'auto' },
+            { type: 'confirm', name: 'claudeWorkspaceStatusLine',
+                message: 'Add workspace repo table to Claude Code status line?',
+                default: current.claudeWorkspaceStatusLine !== false,
+                when: (ans) => ans.aiAgent === 'claude' || ans.aiAgent === 'both' || ans.aiAgent === 'auto' },
+            { type: 'confirm', name: 'autoReportBugs',
+                message: 'Auto-file a GitHub issue when a command crashes? (deduped, sanitized)',
+                default: current.autoReportBugs === true },
+        ]);
+        // Validate and normalize config
+        let primaryAgent = answers.primaryAgent || 'auto';
+        // If aiAgent is specific, primaryAgent must match
+        if (answers.aiAgent === 'claude')
+            primaryAgent = 'claude';
+        if (answers.aiAgent === 'pi')
+            primaryAgent = 'pi';
+        if (answers.aiAgent === 'opencode')
+            primaryAgent = 'opencode';
+        const newConfig = {
+            workspacesDir: answers.workspacesDir.trim(),
+            githubOrg: answers.githubOrg.trim(),
+            cloneProtocol: answers.cloneProtocol,
+            autoLaunchClaude: answers.autoLaunchClaude,
+            generateClaudeContext: answers.generateClaudeContext,
+            installMcp: answers.installMcp,
+            aiAgent: answers.aiAgent,
+            primaryAgent,
+            piWorkspaceInputStatus: answers.piWorkspaceInputStatus ?? current.piWorkspaceInputStatus ?? true,
+            claudeWorkspaceStatusLine: answers.claudeWorkspaceStatusLine ?? current.claudeWorkspaceStatusLine ?? true,
+            autoReportBugs: answers.autoReportBugs ?? current.autoReportBugs ?? false,
+        };
+        (0, config_1.saveUserConfig)(newConfig);
+        console.log('');
+        (0, logger_1.logSuccess)('Configuration saved!');
+        console.log('');
+        console.log(`  ${(0, colors_1.colorize)('Workspaces directory:', 'gray')}  ${newConfig.workspacesDir}`);
+        console.log(`  ${(0, colors_1.colorize)('GitHub organization:', 'gray')}   ${newConfig.githubOrg}`);
+        console.log(`  ${(0, colors_1.colorize)('Clone protocol:', 'gray')}        ${newConfig.cloneProtocol}`);
+        console.log(`  ${(0, colors_1.colorize)('Auto-launch agent:', 'gray')}     ${newConfig.autoLaunchClaude ? 'Yes' : 'No'}`);
+        console.log(`  ${(0, colors_1.colorize)('Generate context:', 'gray')}       ${newConfig.generateClaudeContext ? 'Yes' : 'No'}`);
+        console.log(`  ${(0, colors_1.colorize)('MCP server:', 'gray')}            ${newConfig.installMcp ? 'Yes' : 'No'}`);
+        console.log(`  ${(0, colors_1.colorize)('AI Agent:', 'gray')}              ${newConfig.aiAgent}`);
+        console.log(`  ${(0, colors_1.colorize)('Primary agent:', 'gray')}         ${newConfig.primaryAgent}`);
+        console.log('');
+        // Install / upgrade shell integration.
+        // Skip if MCP install just ran it (mcp/install always installs shell integration).
+        let mcpInstalled = false;
+        if (newConfig.installMcp && !current.installMcp) {
+            (0, logger_1.logInfo)('Installing MCP server...');
+            try {
+                const mcpInstallScript = path.join(__dirname, '..', '..', 'dist', 'mcp', 'install.js');
+                (0, child_process_1.execSync)(`node "${mcpInstallScript}" install`, { stdio: 'inherit' });
+                mcpInstalled = true;
+            }
+            catch {
+                (0, logger_1.logError)('MCP install failed. You can retry later with: w mcp install');
+            }
+        }
+        if (newConfig.githubOrg !== current.githubOrg) {
+            await (0, cache_1.clearCache)();
+            (0, logger_1.logInfo)(`GitHub org changed from "${current.githubOrg}" to "${newConfig.githubOrg}". Repo cache has been cleared.`);
+        }
+        // Always install / upgrade the shell integration so the 'w' function
+        // is available. This is especially important on first-time setup where
+        // postinstall may not have run or the user hasn't sourced their RC file.
+        // Skip if mcp install already did it to avoid printing the reminder twice.
+        if (!mcpInstalled) {
+            installShellIntegration();
+        }
+    }
+    catch (error) {
+        (0, logger_1.logError)('Failed to save configuration');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+        process.exit(1);
+    }
+}
+/**
+ * Install or upgrade the shell integration (w/workspace shell functions).
+ * Uses an absolute path derived from this file so it works regardless of CWD.
+ * Always prints a prominent "source your RC file" reminder afterwards.
+ */
+function installShellIntegration() {
+    // __dirname is dist/commands/ at runtime — script is two levels up at package root
+    const scriptPath = path.join(__dirname, '..', '..', 'install-shell-integration.sh');
+    if (!fs.existsSync(scriptPath)) {
+        (0, logger_1.logWarning)('Shell integration script not found — skipping auto-install');
+        printSourceReminder();
+        return;
+    }
+    const shell = process.env.SHELL || '';
+    const shellType = shell.endsWith('/zsh') ? 'zsh'
+        : shell.endsWith('/bash') ? 'bash'
+            : '';
+    if (!shellType) {
+        (0, logger_1.logWarning)('Unknown shell — skipping shell integration (run install-shell-integration.sh manually)');
+        printSourceReminder();
+        return;
+    }
+    try {
+        (0, child_process_1.execSync)(`bash "${scriptPath}" ${shellType}`, { stdio: 'inherit' });
+    }
+    catch {
+        (0, logger_1.logWarning)('Shell integration install failed — you can run it manually:');
+        (0, logger_1.logInfo)(`  bash "${scriptPath}" ${shellType}`);
+    }
+    printSourceReminder();
+}
+/**
+ * Print a loud, impossible-to-miss reminder to source the RC file.
+ * Without this step the 'w' shell function is not available in the
+ * current terminal session even after a successful install.
+ */
+function printSourceReminder() {
+    const shell = process.env.SHELL || '';
+    const rcFile = shell.endsWith('/zsh') ? '~/.zshrc'
+        : shell.endsWith('/bash') ? '~/.bashrc'
+            : '~/.profile';
+    console.log('');
+    console.log((0, colors_1.colorize)('  ⚠️  IMPORTANT — activate the shell function in this session:', 'yellow'));
+    console.log('');
+    console.log(`     ${(0, colors_1.colorize)(`source ${rcFile}`, 'cyan')}`);
+    console.log('');
+    console.log(`  Or open a new terminal tab. Until then the ${(0, colors_1.colorize)('nemus', 'cyan')}/${(0, colors_1.colorize)('nem', 'cyan')} shell`);
+    console.log(`  functions (which auto-cd into new workspaces) aren't active yet.`);
+    console.log('');
+    console.log(`  Tip: ${(0, colors_1.colorize)('nemus', 'cyan')} works immediately without sourcing:`);
+    console.log(`       ${(0, colors_1.colorize)('nemus configure', 'cyan')}   ${(0, colors_1.colorize)('# first-time setup', 'gray')}`);
+    console.log(`       ${(0, colors_1.colorize)('nemus list', 'cyan')}        ${(0, colors_1.colorize)('# list workspaces', 'gray')}`);
+    console.log('');
+}

package/dist/commands/create.js

@@ -0,0 +1,204 @@
+"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.registerCreateCommand = registerCreateCommand;
+const config_1 = require("../utils/config");
+const path = __importStar(require("path"));
+const github_1 = require("../utils/github");
+const prompts_1 = require("../utils/prompts");
+const git_operations_1 = require("../utils/git-operations");
+const ghq_integration_1 = require("../utils/ghq-integration");
+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 banner_1 = require("../utils/banner");
+const validation_1 = require("../utils/validation");
+const command_helpers_1 = require("../utils/command-helpers");
+const repo_resolver_1 = require("../utils/repo-resolver");
+function registerCreateCommand(parent) {
+    parent
+        .command('create')
+        .alias('c')
+        .description('Create a new workspace')
+        .option('-w, --workspace <name>', 'Workspace name')
+        .option('-r, --repos <repos>', 'Comma-separated repository names. Use repo:suffix to add the same repo more than once under a separate folder, e.g. casper:cas-101 -> casper-cas-101')
+        .option('--prompt <prompt>', 'Original prompt that triggered workspace creation (saved to metadata)')
+        .option('--allow-empty', 'Create the workspace with no repositories (e.g. investigate-first: the agent adds repos later)')
+        .action(async (opts, cmd) => {
+        const globalOpts = (0, command_helpers_1.getGlobalOpts)(cmd);
+        await handleCreate({ ...opts, ...globalOpts });
+    });
+}
+async function handleCreate(opts) {
+    (0, banner_1.printBanner)();
+    try {
+        // Step 1: Verify gh CLI authentication
+        (0, logger_1.logStep)(1, 6, 'Verifying GitHub CLI authentication...');
+        const isAuthenticated = await (0, github_1.verifyGhAuth)();
+        if (!isAuthenticated) {
+            (0, logger_1.logError)('GitHub CLI is not authenticated');
+            (0, github_1.displayAuthInstructions)();
+            process.exit(1);
+        }
+        (0, logger_1.logSuccess)('GitHub CLI authenticated');
+        // Investigate-first empty workspace: no repos to resolve, so skip the org
+        // catalog fetch entirely — otherwise an empty/failed catalog would abort
+        // creation on the guard below even though we need no repos.
+        const investigateEmpty = !!opts.allowEmpty && !opts.repos;
+        // Step 2: Fetch repositories (only when we actually need to resolve repos)
+        let repos = [];
+        if (!investigateEmpty) {
+            (0, logger_1.logStep)(2, 6, 'Fetching repositories...');
+            repos = await (0, github_1.fetchOrgRepos)({ forceRefresh: opts.forceRefresh });
+            if (repos.length === 0) {
+                (0, logger_1.logError)('No repositories found');
+                process.exit(1);
+            }
+        }
+        // Step 3: Select repositories
+        (0, logger_1.logStep)(3, 6, 'Select repositories to clone...');
+        let selectedEntries;
+        if (investigateEmpty) {
+            // Investigate-first: start with no repos; the in-session agent discovers
+            // and adds the relevant repos itself.
+            (0, logger_1.logInfo)('Creating an empty workspace (no repositories) — repos can be added later.');
+            selectedEntries = [];
+        }
+        else if (opts.repos) {
+            const repoSpecs = (0, command_helpers_1.parseList)(opts.repos);
+            const { resolved, notFound, invalidSuffix } = (0, repo_resolver_1.resolveRepoSpecs)(repoSpecs, repos);
+            if (invalidSuffix.length > 0) {
+                (0, logger_1.logError)(`Invalid instance suffix in: ${invalidSuffix.join(', ')}`);
+                (0, logger_1.logInfo)('Use repo:suffix (e.g. casper:cas-101). Suffix may contain letters, numbers, hyphens, underscores.');
+                process.exit(1);
+            }
+            // Warn about fuzzy-resolved names so the user knows what was used
+            for (const r of resolved) {
+                if (!r.exact) {
+                    (0, logger_1.logInfo)(`Repo "${r.input}" not found exactly — using "${(0, colors_1.colorize)(r.repo.name, 'cyan')}" (best match)`);
+                }
+            }
+            if (notFound.length > 0) {
+                (0, logger_1.logError)(`Repositories not found: ${notFound.join(', ')}`);
+                process.exit(1);
+            }
+            selectedEntries = resolved.map(r => ({ repo: r.repo, directoryName: r.directoryName }));
+        }
+        else {
+            selectedEntries = await (0, prompts_1.promptRepositorySelection)(repos);
+        }
+        if (selectedEntries.length === 0 && !opts.allowEmpty) {
+            (0, logger_1.logInfo)('No repositories selected');
+            return;
+        }
+        // Step 4: Get workspace name
+        (0, logger_1.logStep)(4, 6, 'Configure workspace...');
+        let workspaceName;
+        if (opts.workspace) {
+            workspaceName = (0, validation_1.sanitizeWorkspaceName)(opts.workspace);
+            const nameError = (0, validation_1.validateWorkspaceName)(workspaceName);
+            if (nameError !== true) {
+                (0, logger_1.logError)(typeof nameError === 'string' ? nameError : 'Invalid workspace name');
+                process.exit(1);
+            }
+            const exists = await (0, validation_1.checkWorkspaceExists)(workspaceName);
+            if (exists) {
+                const resolved = await (0, validation_1.resolveWorkspaceNameConflict)(workspaceName, selectedEntries.map(e => e.directoryName));
+                (0, logger_1.logInfo)(`Workspace "${workspaceName}" already exists — using "${(0, colors_1.colorize)(resolved, 'cyan')}" instead.`);
+                workspaceName = resolved;
+            }
+        }
+        else {
+            workspaceName = await (0, prompts_1.promptWorkspaceName)();
+            // Auto-resolve conflict in case the interactively chosen name already exists
+            // (the prompt validates format but not uniqueness at this point)
+            const interactiveExists = await (0, validation_1.checkWorkspaceExists)(workspaceName);
+            if (interactiveExists) {
+                const resolved = await (0, validation_1.resolveWorkspaceNameConflict)(workspaceName, selectedEntries.map(e => e.directoryName));
+                (0, logger_1.logInfo)(`Workspace "${workspaceName}" already exists — using "${(0, colors_1.colorize)(resolved, 'cyan')}" instead.`);
+                workspaceName = resolved;
+            }
+        }
+        // Step 5: Confirm
+        const workspacePath = path.join(config_1.WORKSPACES_DIR, workspaceName);
+        if (!opts.yes) {
+            const confirmed = await (0, prompts_1.confirmWorkspaceCreation)(workspaceName, selectedEntries.length, workspacePath);
+            if (!confirmed) {
+                (0, logger_1.logInfo)('Operation cancelled');
+                return;
+            }
+        }
+        // Step 6: Clone repositories
+        (0, logger_1.logStep)(5, 6, 'Creating workspace...');
+        const { mkdir } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        await mkdir(workspacePath, { recursive: true });
+        if (selectedEntries.length > 0)
+            await (0, ghq_integration_1.warnIfGhqMissing)();
+        const results = await (0, git_operations_1.cloneRepositories)(selectedEntries, workspacePath);
+        (0, git_operations_1.reportCloneResults)(results);
+        // Step 7: Save metadata & generate context
+        (0, logger_1.logStep)(6, 6, 'Saving workspace metadata...');
+        const metadata = (0, workspace_meta_1.createMetadata)(workspaceName, results, { prompt: opts.prompt });
+        await (0, workspace_meta_1.saveMetadata)(workspacePath, metadata);
+        const successfulRepos = results
+            .filter(r => r.status === 'success')
+            .map(r => r.repo);
+        // Generate context + .mcp.json even for an empty (investigate-first)
+        // workspace, so the in-session agent lands with the MCP tools (search-repos
+        // / update-workspace) needed to discover and add repos.
+        if (successfulRepos.length > 0 || opts.allowEmpty) {
+            await (0, claude_integration_1.generateClaudeContext)(workspacePath, workspaceName, successfulRepos, metadata);
+        }
+        (0, logger_1.logSuccess)(`Workspace "${(0, colors_1.colorize)(workspaceName, 'cyan')}" created successfully!`);
+        // Write workspace path to temp file for shell integration auto-CD
+        const { writeFile } = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+        const os = await Promise.resolve().then(() => __importStar(require('os')));
+        const tempFile = path.join(os.homedir(), '.workspace-last-created');
+        try {
+            await writeFile(tempFile, workspacePath, 'utf-8');
+        }
+        catch {
+            // Non-critical — shell integration CD won't work but workspace was created
+        }
+    }
+    catch (error) {
+        (0, logger_1.logError)('Failed to create workspace');
+        if (error instanceof Error) {
+            (0, logger_1.logError)(error.message);
+        }
+        process.exit(1);
+    }
+}

package/dist/commands/dashboard/hook-handler.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Hook handler for Claude Code hooks.
+ * Invoked via ~/.claude/settings.json hooks — reads JSON from stdin,
+ * maps the event to an agent status, and writes to state file.
+ *
+ * Status model:
+ *   idle    — agent is not working (new, finished, waiting for input)
+ *   working — agent is actively processing (thinking, calling tools)
+ *   waiting — agent needs user action (permission approval)
+ *   stopped — session ended
+ *
+ * Event mapping:
+ *   SessionStart      → idle     (session opened, not working yet)
+ *   UserPromptSubmit  → working  (user sent prompt, agent starts)
+ *   PreToolUse        → working  (agent calling a tool)
+ *   PostToolUse       → working  (tool done, agent still processing)
+ *   Notification:
+ *     permission_prompt → waiting (needs user to approve tool use)
+ *     idle_prompt       → idle    (agent finished, waiting for input)
+ *   Stop              → idle     (agent finished its turn)
+ *   SessionEnd        → stopped  (session ended)
+ *
+ * IMPORTANT: Must never write to stderr or throw — always exit 0.
+ */
+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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const agent_state_1 = require("../../utils/agent-state");
+const config_1 = require("../../utils/config");
+function main() {
+    try {
+        const args = process.argv.slice(2);
+        const eventIdx = args.indexOf('--event');
+        const event = eventIdx >= 0 ? args[eventIdx + 1] : null;
+        if (!event) {
+            process.exit(0);
+        }
+        let input;
+        try {
+            const raw = fs.readFileSync('/dev/stdin', 'utf-8');
+            input = JSON.parse(raw);
+        }
+        catch {
+            process.exit(0);
+        }
+        const sessionId = input.session_id;
+        if (!sessionId || !/^[a-zA-Z0-9\-]{1,100}$/.test(sessionId)) {
+            process.exit(0); // reject missing or invalid session IDs
+        }
+        (0, agent_state_1.ensureStateDir)();
+        let newStatus;
+        switch (event) {
+            case 'SessionStart':
+                newStatus = 'idle';
+                break;
+            case 'UserPromptSubmit':
+                newStatus = 'working';
+                break;
+            case 'PreToolUse':
+                newStatus = 'working';
+                break;
+            case 'PostToolUse':
+                newStatus = 'working';
+                break;
+            case 'Notification': {
+                const notifType = input.notification_type || '';
+                if (notifType === 'permission_prompt') {
+                    newStatus = 'waiting'; // needs user to approve
+                }
+                else if (notifType === 'idle_prompt') {
+                    newStatus = 'idle'; // just idle, not a special state
+                }
+                else {
+                    process.exit(0);
+                }
+                break;
+            }
+            case 'Stop':
+                newStatus = 'idle';
+                break;
+            case 'SessionEnd':
+                newStatus = 'stopped';
+                break;
+            default:
+                process.exit(0);
+        }
+        const now = new Date().toISOString();
+        const existing = (0, agent_state_1.readAgentState)(sessionId);
+        if (existing) {
+            existing.status = newStatus;
+            existing.lastUpdatedAt = now;
+            // Always update PID — handles resumed sessions where the old
+            // process is dead but session ID is reused with a new process
+            existing.pid = process.ppid || existing.pid;
+            (0, agent_state_1.writeAgentState)(existing);
+            process.exit(0);
+        }
+        // New session — infer workspace from cwd
+        const cwd = input.cwd || process.cwd();
+        let workspace = 'unknown';
+        let workspacePath = cwd;
+        const workspacesDir = config_1.WORKSPACES_DIR;
+        if (cwd.startsWith(workspacesDir + path.sep) || cwd === workspacesDir) {
+            const relative = cwd.slice(workspacesDir.length + 1);
+            const parts = relative.split(path.sep);
+            if (parts[0]) {
+                workspace = parts[0];
+                workspacePath = path.join(workspacesDir, workspace);
+            }
+        }
+        const state = {
+            sessionId,
+            workspace,
+            workspacePath,
+            pid: process.ppid || 0,
+            status: newStatus,
+            startedAt: now,
+            lastUpdatedAt: now,
+        };
+        (0, agent_state_1.writeAgentState)(state);
+        process.exit(0);
+    }
+    catch {
+        process.exit(0);
+    }
+}
+main();