@iloom/cli 0.3.4 → 0.4.1

package/dist/hooks/iloom-hook.js

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+/* eslint-env node */
+/* eslint-disable no-undef */
+/**
+ * iloom-hook.js - Claude Code hook script for iloom-vscode integration
+ *
+ * This script is called by Claude Code on various events and broadcasts
+ * relevant session state changes to all iloom-vscode extension instances
+ * via Unix sockets.
+ *
+ * Events we handle:
+ * - Stop → waiting_for_input (Claude finished turn)
+ * - PermissionRequest → waiting_for_approval (needs permission)
+ * - PreToolUse → working (tool about to execute)
+ * - PostToolUse → working (tool finished, clears approval)
+ * - SessionEnd → ended (clear notifications)
+ * - Notification(idle_prompt) → idle_reminder (60s reminder)
+ * - Notification(elicitation_dialog) → tool_input_needed (MCP tool question)
+ *
+ * Events we skip (exit without broadcasting):
+ * - SessionStart - user just launched, they know
+ * - SubagentStop - subagent done but main agent may continue
+ * - Notification(permission_prompt) - redundant with PermissionRequest
+ * - Notification(auth_success) - user just logged in
+ * - Any other notification types
+ *
+ * This is purely a notification mechanism - it does NOT participate in
+ * permission approval/denial. Claude Code handles permission prompts in
+ * the terminal as normal.
+ *
+ * Debug logging: Set ILOOM_HOOK_DEBUG=1 to enable logging to /tmp/iloom-hook.log
+ */
+
+const fs = require('fs');
+const net = require('net');
+const path = require('path');
+
+// Debug logging - writes to /tmp/iloom-hook.log
+// Set ILOOM_HOOK_DEBUG=0 to disable (enabled by default for now)
+const DEBUG = process.env.ILOOM_HOOK_DEBUG !== '0';
+const LOG_FILE = '/tmp/iloom-hook.log';
+
+function debug(message, data = {}) {
+  if (!DEBUG) return;
+
+  const timestamp = new Date().toISOString();
+  const dataStr = Object.keys(data).length > 0 ? ` ${JSON.stringify(data)}` : '';
+  const logLine = `[${timestamp}] ${message}${dataStr}\n`;
+
+  try {
+    fs.appendFileSync(LOG_FILE, logLine);
+  } catch {
+    // Ignore logging errors
+  }
+}
+
+/**
+ * Read JSON from stdin until EOF
+ * @returns {Promise<object>} Parsed JSON data from Claude Code
+ */
+async function readStdin() {
+  return new Promise((resolve, reject) => {
+    let data = '';
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      data += chunk;
+    });
+
+    process.stdin.on('end', () => {
+      try {
+        const parsed = JSON.parse(data);
+        resolve(parsed);
+      } catch (error) {
+        reject(new Error(`Failed to parse stdin JSON: ${error.message}`));
+      }
+    });
+
+    process.stdin.on('error', reject);
+  });
+}
+
+/**
+ * Find all iloom sockets in /tmp
+ *
+ * @returns {string[]} Array of socket paths
+ */
+function findAllIloomSockets() {
+  try {
+    const tmpDir = '/tmp';
+    const files = fs.readdirSync(tmpDir);
+    const sockets = files
+      .filter(file => file.startsWith('iloom-') && file.endsWith('.sock'))
+      .map(file => path.join(tmpDir, file))
+      .filter(socketPath => {
+        // Verify it's actually a socket
+        try {
+          const stat = fs.statSync(socketPath);
+          return stat.isSocket();
+        } catch {
+          return false;
+        }
+      });
+
+    return sockets;
+  } catch (error) {
+    debug('Error finding iloom sockets', { error: error.message });
+    return [];
+  }
+}
+
+/**
+ * Map hook event name to session status
+ *
+ * @param {string} eventName - The hook_event_name from Claude Code
+ * @param {string|undefined} notificationType - notification_type for Notification events
+ * @returns {string|null} Status string for iloom-vscode, or null if event should be skipped
+ */
+function mapEventToStatus(eventName, notificationType) {
+  switch (eventName) {
+    case 'Stop':
+      return 'waiting_for_input';
+
+    case 'PermissionRequest':
+      return 'waiting_for_approval';
+
+    case 'PreToolUse':
+    case 'PostToolUse':
+      return 'working';
+
+    case 'SessionEnd':
+      return 'ended';
+
+    case 'Notification':
+      if (notificationType === 'idle_prompt') {
+        return 'idle_reminder';
+      }
+      if (notificationType === 'elicitation_dialog') {
+        return 'tool_input_needed';
+      }
+      // Other notification types - not relevant, skip
+      return null;
+
+    default:
+      // Other events (SessionStart, SubagentStop, etc.) - not relevant, skip
+      return null;
+  }
+}
+
+/**
+ * Send status to a single socket (fire and forget)
+ *
+ * @param {string} socketPath - Path to Unix socket
+ * @param {string} status - Session status
+ * @param {object} hookData - Full hook data from Claude Code
+ * @returns {Promise<void>}
+ */
+async function sendStatus(socketPath, status, hookData) {
+  return new Promise((resolve) => {
+    const client = net.createConnection(socketPath, () => {
+      const message = JSON.stringify({
+        type: 'session_status',
+        status,
+        session_id: hookData.session_id,
+        hook_event_name: hookData.hook_event_name,
+        cwd: hookData.cwd,
+        tool_name: hookData.tool_name,
+        tool_input: hookData.tool_input,
+        notification_type: hookData.notification_type,
+        timestamp: new Date().toISOString()
+      });
+
+      client.write(message + '\n');
+      // Fire and forget - close connection immediately after sending
+      client.end();
+      resolve();
+    });
+
+    // Handle connection errors silently
+    client.on('error', () => {
+      resolve();
+    });
+  });
+}
+
+/**
+ * Broadcast status to all iloom sockets (fire and forget)
+ * Each VSCode instance can filter messages by cwd if needed
+ *
+ * @param {string[]} socketPaths - Array of socket paths to broadcast to
+ * @param {string} status - Session status
+ * @param {object} hookData - Full hook data from Claude Code
+ */
+async function broadcastStatus(socketPaths, status, hookData) {
+  debug('Broadcasting to all sockets', { count: socketPaths.length, socketPaths });
+
+  const promises = socketPaths.map(socketPath => {
+    return sendStatus(socketPath, status, hookData).catch(error => {
+      debug('Broadcast failed for socket', { socketPath, error: error.message });
+      return null;
+    });
+  });
+
+  // Wait for all broadcasts to complete (or fail)
+  await Promise.allSettled(promises);
+  debug('Broadcast completed');
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+  debug('Hook invoked', { ILOOM: process.env.ILOOM, ILOOM_HOOK_DEBUG: process.env.ILOOM_HOOK_DEBUG });
+
+  // Only run when launched via iloom (ILOOM=1)
+  // This prevents the hook from doing anything when Claude is run directly
+  if (process.env.ILOOM !== '1') {
+    debug('ILOOM not set, exiting silently');
+    process.exit(0);
+  }
+
+  try {
+    const hookData = await readStdin();
+    const { hook_event_name, cwd, notification_type, session_id } = hookData;
+
+    debug('Received hook event', { hook_event_name, cwd, notification_type, session_id, tool_name: hookData.tool_name });
+
+    const status = mapEventToStatus(hook_event_name, notification_type);
+    debug('Mapped event to status', { status });
+
+    // Skip events we don't care about
+    if (status === null) {
+      debug('Event not relevant, skipping');
+      process.exit(0);
+    }
+
+    // Find all iloom sockets for broadcasting
+    const allSockets = findAllIloomSockets();
+    debug('Found iloom sockets', { count: allSockets.length, sockets: allSockets });
+
+    // If no sockets exist, exit silently (no VSCode extensions running)
+    if (allSockets.length === 0) {
+      debug('No iloom sockets found, exiting');
+      process.exit(0);
+    }
+
+    // Broadcast status to all sockets (fire and forget)
+    // All events including PermissionRequest are just notifications
+    await broadcastStatus(allSockets, status, hookData);
+
+    debug('Hook completed successfully');
+  } catch (error) {
+    debug('Hook error', { error: error.message, stack: error.stack });
+    // Silent failure - don't interrupt Claude
+  }
+}
+
+main().catch(() => process.exit(0));

package/dist/{ignite-T74RYXCA.js → ignite-3B264M7K.js}

@@ -3,59 +3,261 @@ import {
   FirstRunManager,
   IssueTrackerFactory,
   generateIssueManagementMcpConfig
-} from "./chunk-DLHA5VQ3.js";
+} from "./chunk-HD5SUKI2.js";
+import "./chunk-QHA67Q7A.js";
 import {
   AgentManager
-} from "./chunk-OC4H6HJD.js";
+} from "./chunk-O7WHXLCB.js";
 import {
   GitWorktreeManager
-} from "./chunk-2CXREBLZ.js";
-import {
-  PromptTemplateManager
-} from "./chunk-RIEO2WML.js";
+} from "./chunk-JC5HXN75.js";
 import {
   extractSettingsOverrides
 } from "./chunk-GYCR2LOU.js";
 import {
   extractIssueNumber
-} from "./chunk-5Q3NDNNV.js";
+} from "./chunk-2W2FBL5G.js";
+import {
+  MetadataManager
+} from "./chunk-IJ7IGJT3.js";
 import {
   SettingsManager
-} from "./chunk-CDZERT7Z.js";
-import "./chunk-M7JJCX53.js";
-import "./chunk-3RUPPQRG.js";
-import "./chunk-CE26YH2U.js";
+} from "./chunk-VWNS6DH5.js";
+import "./chunk-OEGECBFS.js";
+import "./chunk-KO2FOMHL.js";
+import "./chunk-SJ2GZ6RF.js";
 import {
+  generateDeterministicSessionId,
   launchClaude
-} from "./chunk-OYF4VIFI.js";
-import "./chunk-RW54ZMBM.js";
-import "./chunk-UJL4HI2R.js";
+} from "./chunk-RUC7OULH.js";
+import "./chunk-VAYGNQTE.js";
+import "./chunk-Z5NXYJIG.js";
+import "./chunk-6UIGZD2N.js";
+import {
+  PromptTemplateManager
+} from "./chunk-74VMN2KC.js";
 import {
   logger
-} from "./chunk-GEHQXLEI.js";
+} from "./chunk-UYVWLISQ.js";
 
 // src/commands/ignite.ts
-import path from "path";
+import path2 from "path";
 import { readFile } from "fs/promises";
+
+// src/lib/ClaudeHookManager.ts
+import os from "os";
+import path from "path";
+import fs from "fs-extra";
+import { parse, modify, applyEdits } from "jsonc-parser";
+import { fileURLToPath } from "url";
+import { accessSync } from "fs";
+var ClaudeHookManager = class {
+  constructor() {
+    this.claudeDir = path.join(os.homedir(), ".claude");
+    this.hooksDir = path.join(this.claudeDir, "hooks");
+    this.settingsPath = path.join(this.claudeDir, "settings.json");
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = fileURLToPath(currentFileUrl);
+    const distDir = path.dirname(currentFilePath);
+    let templateDir = path.join(distDir, "hooks");
+    let currentDir = distDir;
+    while (currentDir !== path.dirname(currentDir)) {
+      const candidatePath = path.join(currentDir, "hooks");
+      try {
+        accessSync(candidatePath);
+        templateDir = candidatePath;
+        break;
+      } catch {
+        currentDir = path.dirname(currentDir);
+      }
+    }
+    this.templateDir = templateDir;
+    logger.debug("ClaudeHookManager initialized", {
+      claudeDir: this.claudeDir,
+      hooksDir: this.hooksDir,
+      settingsPath: this.settingsPath,
+      templateDir: this.templateDir
+    });
+  }
+  /**
+   * Install Claude hooks for VSCode integration
+   *
+   * This is idempotent - safe to call on every spin.
+   * Installs hook script to ~/.claude/hooks/ and merges
+   * hook configuration into ~/.claude/settings.json
+   */
+  async installHooks() {
+    try {
+      await fs.ensureDir(this.hooksDir);
+      await this.installHookScript();
+      await this.mergeHookConfig();
+      logger.debug("Claude hooks installed successfully");
+    } catch (error) {
+      logger.warn(
+        `Failed to install Claude hooks: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Check if hooks are already installed
+   */
+  async isHooksInstalled() {
+    try {
+      const hookScriptPath = path.join(this.hooksDir, "iloom-hook.js");
+      if (!await fs.pathExists(hookScriptPath)) {
+        return false;
+      }
+      if (!await fs.pathExists(this.settingsPath)) {
+        return false;
+      }
+      const content = await fs.readFile(this.settingsPath, "utf8");
+      const errors = [];
+      const settings = parse(content, errors, { allowTrailingComma: true });
+      if (errors.length > 0 || !(settings == null ? void 0 : settings.hooks)) {
+        return false;
+      }
+      return Array.isArray(settings.hooks.SessionStart);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Install the hook script from bundled templates
+   * Skips write if destination already has identical content
+   */
+  async installHookScript() {
+    const sourcePath = path.join(this.templateDir, "iloom-hook.js");
+    const destPath = path.join(this.hooksDir, "iloom-hook.js");
+    if (!await fs.pathExists(sourcePath)) {
+      throw new Error(`Hook template not found at ${sourcePath}`);
+    }
+    if (await fs.pathExists(destPath)) {
+      const [sourceContent, destContent] = await Promise.all([
+        fs.readFile(sourcePath, "utf8"),
+        fs.readFile(destPath, "utf8")
+      ]);
+      if (sourceContent === destContent) {
+        logger.debug("Hook script already up to date, skipping");
+        return;
+      }
+    }
+    await fs.copyFile(sourcePath, destPath);
+    logger.debug("Hook script installed", { sourcePath, destPath });
+  }
+  /**
+   * Merge hook configuration into settings.json
+   * Preserves existing user hooks and comments
+   */
+  async mergeHookConfig() {
+    var _a, _b, _c;
+    await fs.ensureDir(this.claudeDir);
+    let existingContent = "{}";
+    let existingSettings = {};
+    if (await fs.pathExists(this.settingsPath)) {
+      existingContent = await fs.readFile(this.settingsPath, "utf8");
+      const errors = [];
+      existingSettings = parse(existingContent, errors, { allowTrailingComma: true });
+      if (errors.length > 0) {
+        logger.warn("Existing settings.json has parse errors, will attempt to merge anyway");
+      }
+    }
+    const ourHooks = this.getHookConfig();
+    const mergedHooks = { ...existingSettings.hooks ?? {} };
+    let hooksAdded = false;
+    for (const [eventName, eventConfigs] of Object.entries(ourHooks)) {
+      const existing = mergedHooks[eventName] ?? [];
+      const ourCommand = (_c = (_b = (_a = eventConfigs[0]) == null ? void 0 : _a.hooks) == null ? void 0 : _b[0]) == null ? void 0 : _c.command;
+      const alreadyRegistered = existing.some(
+        (config) => {
+          var _a2;
+          return (_a2 = config.hooks) == null ? void 0 : _a2.some((h) => h.command === ourCommand);
+        }
+      );
+      if (!alreadyRegistered) {
+        mergedHooks[eventName] = [...existing, ...eventConfigs];
+        hooksAdded = true;
+      }
+    }
+    if (!hooksAdded) {
+      logger.debug("All hooks already registered, skipping settings.json update");
+      return;
+    }
+    let content;
+    if (existingContent.includes("//") || existingContent.includes("/*")) {
+      let modifiedContent = existingContent;
+      const edits = modify(modifiedContent, ["hooks"], mergedHooks, {});
+      content = applyEdits(modifiedContent, edits);
+    } else {
+      const updatedSettings = {
+        ...existingSettings,
+        hooks: mergedHooks
+      };
+      content = JSON.stringify(updatedSettings, null, 2) + "\n";
+    }
+    const tempPath = `${this.settingsPath}.tmp`;
+    await fs.writeFile(tempPath, content, "utf8");
+    await fs.rename(tempPath, this.settingsPath);
+    logger.debug("Hook configuration merged into settings.json");
+  }
+  /**
+   * Get the hook configuration to register
+   *
+   * Each event maps to a hook that runs iloom-hook.js
+   */
+  getHookConfig() {
+    const hookCommand = `node ${path.join(this.hooksDir, "iloom-hook.js")}`;
+    return {
+      Notification: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      Stop: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      SubagentStop: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      PermissionRequest: [
+        { matcher: "*", hooks: [{ type: "command", command: hookCommand, timeout: 86400 }] }
+      ],
+      PreToolUse: [
+        { matcher: "*", hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      PostToolUse: [
+        { matcher: "*", hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      SessionStart: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ],
+      SessionEnd: [
+        { hooks: [{ type: "command", command: hookCommand }] }
+      ]
+    };
+  }
+};
+
+// src/commands/ignite.ts
 var IgniteCommand = class {
-  constructor(templateManager, gitWorktreeManager, agentManager, settingsManager, firstRunManager) {
+  constructor(templateManager, gitWorktreeManager, agentManager, settingsManager, firstRunManager, hookManager) {
     this.templateManager = templateManager ?? new PromptTemplateManager();
     this.gitWorktreeManager = gitWorktreeManager ?? new GitWorktreeManager();
     this.agentManager = agentManager ?? new AgentManager();
     this.settingsManager = settingsManager ?? new SettingsManager();
     this.firstRunManager = firstRunManager ?? new FirstRunManager("spin");
+    this.hookManager = hookManager ?? new ClaudeHookManager();
   }
   /**
    * Main entry point for spin command
    */
   async execute(oneShot = "default") {
     var _a;
+    process.env.ILOOM = "1";
     try {
       logger.info("\u{1F680} Your loom is spinning up, please wait...");
       const isFirstRun = await this.firstRunManager.isFirstRun();
       if (isFirstRun) {
         logger.success("Welcome to iloom! Preparing first-time experience...");
       }
+      await this.hookManager.installHooks();
       const context = await this.detectWorkspaceContext();
       logger.debug("Auto-detected workspace context", { context });
       this.logDetectedContext(context);
@@ -72,7 +274,7 @@ var IgniteCommand = class {
         const cliOverrides = extractSettingsOverrides();
         this.settings = await this.settingsManager.loadSettings(void 0, cliOverrides);
       }
-      const model = this.getModelForWorkflow(context.type);
+      const model = this.settingsManager.getSpinModel(this.settings);
       let permissionMode = this.getPermissionModeForWorkflow(context.type);
       if (oneShot === "bypassPermissions") {
         permissionMode = "bypassPermissions";
@@ -82,10 +284,22 @@ var IgniteCommand = class {
           "\u26A0\uFE0F  WARNING: Using bypassPermissions mode - Claude will execute all tool calls without confirmation. This can be dangerous. Use with caution."
         );
       }
+      let sessionId;
+      const metadataManager = new MetadataManager();
+      const metadata = await metadataManager.readMetadata(context.workspacePath);
+      if (metadata == null ? void 0 : metadata.sessionId) {
+        sessionId = metadata.sessionId;
+        logger.debug("Using session ID from metadata", { sessionId });
+      } else {
+        sessionId = generateDeterministicSessionId(context.workspacePath);
+        logger.debug("Generated session ID (no metadata found)", { sessionId, workspacePath: context.workspacePath });
+      }
       const claudeOptions = {
         headless: false,
         // Enable stdio: 'inherit' for current terminal
-        addDir: context.workspacePath
+        addDir: context.workspacePath,
+        sessionId
+        // Enable Claude Code session resume
       };
       if (model !== void 0) {
         claudeOptions.model = model;
@@ -200,19 +414,11 @@ var IgniteCommand = class {
     }
     if (oneShot === "noReview" || oneShot === "bypassPermissions") {
       variables.ONE_SHOT_MODE = true;
+    } else {
+      variables.INTERACTIVE_MODE = true;
     }
     return variables;
   }
-  /**
-   * Get the appropriate model for a workflow type
-   * Same logic as ClaudeService.getModelForWorkflow()
-   */
-  getModelForWorkflow(type) {
-    if (type === "issue") {
-      return "claude-sonnet-4-20250514";
-    }
-    return void 0;
-  }
   /**
    * Get the appropriate permission mode for a workflow type
    * Same logic as ClaudeService.getPermissionModeForWorkflow()
@@ -242,7 +448,7 @@ var IgniteCommand = class {
    */
   async detectWorkspaceContext() {
     const workspacePath = process.cwd();
-    const currentDir = path.basename(workspacePath);
+    const currentDir = path2.basename(workspacePath);
     const prPattern = /_pr_(\d+)$/;
     const prMatch = currentDir.match(prPattern);
     if (prMatch == null ? void 0 : prMatch[1]) {
@@ -380,15 +586,15 @@ var IgniteCommand = class {
    */
   async loadReadmeContent() {
     try {
-      let currentDir = path.dirname(new URL(import.meta.url).pathname);
-      while (currentDir !== path.dirname(currentDir)) {
-        const readmePath = path.join(currentDir, "README.md");
+      let currentDir = path2.dirname(new URL(import.meta.url).pathname);
+      while (currentDir !== path2.dirname(currentDir)) {
+        const readmePath = path2.join(currentDir, "README.md");
         try {
           const content = await readFile(readmePath, "utf-8");
           logger.debug("Loaded README.md for first-time user", { readmePath });
           return content;
         } catch {
-          currentDir = path.dirname(currentDir);
+          currentDir = path2.dirname(currentDir);
         }
       }
       logger.debug("README.md not found, returning empty string");
@@ -404,15 +610,15 @@ var IgniteCommand = class {
    */
   async loadSettingsSchemaContent() {
     try {
-      let currentDir = path.dirname(new URL(import.meta.url).pathname);
-      while (currentDir !== path.dirname(currentDir)) {
-        const schemaPath = path.join(currentDir, ".iloom", "README.md");
+      let currentDir = path2.dirname(new URL(import.meta.url).pathname);
+      while (currentDir !== path2.dirname(currentDir)) {
+        const schemaPath = path2.join(currentDir, ".iloom", "README.md");
         try {
           const content = await readFile(schemaPath, "utf-8");
           logger.debug("Loaded .iloom/README.md for first-time user", { schemaPath });
           return content;
         } catch {
-          currentDir = path.dirname(currentDir);
+          currentDir = path2.dirname(currentDir);
         }
       }
       logger.debug(".iloom/README.md not found, returning empty string");
@@ -426,4 +632,4 @@ var IgniteCommand = class {
 export {
   IgniteCommand
 };
-//# sourceMappingURL=ignite-T74RYXCA.js.map
+//# sourceMappingURL=ignite-3B264M7K.js.map