chainlesschain 0.37.10 → 0.37.12

package/src/commands/hook.js

@@ -0,0 +1,260 @@
+/**
+ * Hook management commands
+ * chainlesschain hook list|add|remove|run|stats|events
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  HookPriority,
+  HookType,
+  HookEvents,
+  registerHook,
+  unregisterHook,
+  listHooks,
+  executeHooks,
+  getHookStats,
+} from "../lib/hook-manager.js";
+
+export function registerHookCommand(program) {
+  const hook = program.command("hook").description("Lifecycle hook management");
+
+  // hook list
+  hook
+    .command("list", { isDefault: true })
+    .description("List all registered hooks")
+    .option("--event <name>", "Filter by event name")
+    .option("--enabled", "Show only enabled hooks")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const hooks = listHooks(db, {
+          event: options.event,
+          enabledOnly: options.enabled,
+        });
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              hooks.map((h) => ({
+                id: h.id,
+                event: h.event,
+                name: h.name,
+                type: h.type,
+                priority: h.priority,
+                enabled: h.enabled === 1,
+                matcher: h.matcher,
+                description: h.description,
+              })),
+              null,
+              2,
+            ),
+          );
+        } else if (hooks.length === 0) {
+          logger.info(
+            'No hooks registered. Add one with "chainlesschain hook add <event> <name>"',
+          );
+        } else {
+          logger.log(chalk.bold(`Hooks (${hooks.length}):\n`));
+          for (const h of hooks) {
+            const status = h.enabled
+              ? chalk.green("enabled")
+              : chalk.gray("disabled");
+            const pLabel = Object.entries(HookPriority).find(
+              ([, v]) => v === h.priority,
+            );
+            const priorityStr = pLabel ? pLabel[0] : String(h.priority);
+            logger.log(
+              `  ${chalk.cyan(h.name)} [${h.event}] priority=${priorityStr} type=${h.type} [${status}]`,
+            );
+            if (h.description) logger.log(`    ${chalk.gray(h.description)}`);
+            if (h.matcher)
+              logger.log(`    matcher: ${chalk.yellow(h.matcher)}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hook add
+  hook
+    .command("add")
+    .description("Register a new hook")
+    .argument("<event>", "Event name (e.g. PreIPCCall, PostToolUse)")
+    .argument("<name>", "Hook name")
+    .option("--type <type>", "Hook type (sync, async, command, script)", "sync")
+    .option(
+      "--priority <n>",
+      "Priority (0=system, 100=high, 500=normal, 900=low, 1000=monitor)",
+      "500",
+    )
+    .option(
+      "--command <cmd>",
+      "Shell command to execute (for command/script type)",
+    )
+    .option(
+      "--matcher <pattern>",
+      "Matcher pattern (wildcards, pipe-separated, or /regex/)",
+    )
+    .option("--description <desc>", "Hook description")
+    .action(async (event, name, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+
+        const result = registerHook(db, {
+          event,
+          name,
+          type: options.type,
+          priority: parseInt(options.priority, 10),
+          handler: options.command || null,
+          matcher: options.matcher || null,
+          description: options.description || null,
+        });
+
+        logger.success(
+          `Hook registered: ${result.name} [${result.event}] (id: ${result.id})`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hook remove
+  hook
+    .command("remove")
+    .description("Remove a hook by ID")
+    .argument("<id>", "Hook ID")
+    .action(async (id) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = unregisterHook(db, id);
+
+        if (ok) {
+          logger.success(`Hook removed: ${id}`);
+        } else {
+          logger.error(`Hook not found: ${id}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hook run
+  hook
+    .command("run")
+    .description("Manually trigger hooks for an event")
+    .argument("<event>", "Event name to trigger")
+    .option("--context <json>", "JSON context to pass to hooks", "{}")
+    .action(async (event, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+
+        let context = {};
+        try {
+          context = JSON.parse(options.context);
+        } catch (_err) {
+          logger.warn("Invalid JSON context, using empty object");
+        }
+
+        logger.info(`Triggering hooks for event: ${event}`);
+        const results = await executeHooks(db, event, context);
+
+        if (results.length === 0) {
+          logger.info("No hooks matched this event");
+        } else {
+          for (const r of results) {
+            const icon = r.success ? chalk.green("OK") : chalk.red("FAIL");
+            logger.log(`  [${icon}] ${r.hookName} (${r.executionTime}ms)`);
+            if (r.error) logger.log(`    ${chalk.red(r.error)}`);
+            if (r.result) logger.log(`    ${chalk.gray(r.result)}`);
+          }
+          logger.info(`Executed ${results.length} hook(s)`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hook stats
+  hook
+    .command("stats")
+    .description("Show hook execution statistics")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const stats = getHookStats(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(stats, null, 2));
+        } else if (stats.length === 0) {
+          logger.info("No hooks registered");
+        } else {
+          logger.log(chalk.bold("Hook Statistics:\n"));
+          for (const s of stats) {
+            logger.log(`  ${chalk.cyan(s.name)} [${s.event}]`);
+            logger.log(
+              `    executions: ${s.executionCount}  errors: ${s.errorCount}  avg: ${s.avgExecutionTime}ms`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // hook events
+  hook
+    .command("events")
+    .description("List all valid hook event types")
+    .action(() => {
+      const events = Object.values(HookEvents);
+      logger.log(chalk.bold(`Hook Events (${events.length}):\n`));
+      for (const ev of events) {
+        logger.log(`  ${chalk.cyan(ev)}`);
+      }
+    });
+}

package/src/commands/init.js

@@ -0,0 +1,184 @@
+/**
+ * Project initialization command
+ * chainlesschain init [--template <name>] [--yes] [--bare]
+ *
+ * Creates .chainlesschain/ project structure in the current directory.
+ */
+
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { logger } from "../lib/logger.js";
+import { isInsideProject, findProjectRoot } from "../lib/project-detector.js";
+
+const TEMPLATES = {
+  "code-project": {
+    description:
+      "Software development project with code review and refactoring skills",
+    rules: `# Project Rules
+
+## Code Style
+- Follow the project's existing code style
+- Use meaningful variable and function names
+- Keep functions small and focused
+
+## AI Assistant Guidelines
+- Prefer editing existing files over creating new ones
+- Run tests after making changes
+- Use code-review skill before committing
+`,
+    skills: ["code-review", "refactor", "unit-test", "debug"],
+  },
+  "data-science": {
+    description:
+      "Data science / ML project with analysis and visualization skills",
+    rules: `# Project Rules
+
+## Data Handling
+- Never commit raw data files
+- Document data transformations
+- Use reproducible random seeds
+
+## AI Assistant Guidelines
+- Use data-analysis skill for exploration
+- Document findings in markdown
+- Validate results before reporting
+`,
+    skills: ["data-analysis", "summarize", "explain-code"],
+  },
+  devops: {
+    description:
+      "DevOps / infrastructure project with deployment and monitoring skills",
+    rules: `# Project Rules
+
+## Infrastructure
+- Use infrastructure as code
+- Tag all resources appropriately
+- Follow least-privilege principle
+
+## AI Assistant Guidelines
+- Always validate configs before applying
+- Use dry-run when available
+- Document infrastructure changes
+`,
+    skills: ["debug", "summarize", "code-review"],
+  },
+  empty: {
+    description: "Bare project with minimal configuration",
+    rules: `# Project Rules
+
+Add your project-specific rules and conventions here.
+The AI assistant will follow these guidelines when working in this project.
+`,
+    skills: [],
+  },
+};
+
+export function registerInitCommand(program) {
+  program
+    .command("init")
+    .description(
+      "Initialize a .chainlesschain/ project in the current directory",
+    )
+    .option(
+      "-t, --template <name>",
+      "Project template (code-project, data-science, devops, empty)",
+      "empty",
+    )
+    .option("-y, --yes", "Skip prompts, use defaults")
+    .option(
+      "--bare",
+      "Create minimal structure (alias for --template empty --yes)",
+    )
+    .action(async (options) => {
+      const cwd = process.cwd();
+      const ccDir = path.join(cwd, ".chainlesschain");
+
+      // Check if already initialized
+      if (fs.existsSync(path.join(ccDir, "config.json"))) {
+        const existingRoot = findProjectRoot(cwd);
+        logger.error(
+          `Already initialized at ${existingRoot || cwd}. Remove .chainlesschain/ to reinitialize.`,
+        );
+        process.exit(1);
+      }
+
+      // Determine template
+      let template = options.bare ? "empty" : options.template;
+      if (!TEMPLATES[template]) {
+        logger.error(
+          `Unknown template: ${template}. Available: ${Object.keys(TEMPLATES).join(", ")}`,
+        );
+        process.exit(1);
+      }
+
+      // Interactive selection if not --yes/--bare
+      if (!options.yes && !options.bare) {
+        try {
+          const { select } = await import("@inquirer/prompts");
+          template = await select({
+            message: "Select a project template:",
+            choices: Object.entries(TEMPLATES).map(([key, val]) => ({
+              name: `${key} — ${val.description}`,
+              value: key,
+            })),
+            default: template,
+          });
+        } catch {
+          // Ctrl+C or non-interactive — use default
+        }
+      }
+
+      const tmpl = TEMPLATES[template];
+      const projectName = path.basename(cwd);
+
+      // Create directory structure
+      try {
+        fs.mkdirSync(ccDir, { recursive: true });
+        fs.mkdirSync(path.join(ccDir, "skills"), { recursive: true });
+
+        // config.json
+        const config = {
+          name: projectName,
+          template,
+          version: "1.0.0",
+          createdAt: new Date().toISOString(),
+          skills: {
+            workspace: "./skills",
+          },
+        };
+        fs.writeFileSync(
+          path.join(ccDir, "config.json"),
+          JSON.stringify(config, null, 2),
+          "utf-8",
+        );
+
+        // rules.md
+        fs.writeFileSync(path.join(ccDir, "rules.md"), tmpl.rules, "utf-8");
+
+        logger.success(
+          `Initialized ChainlessChain project in ${chalk.cyan(cwd)}`,
+        );
+        logger.log("");
+        logger.log(`  Template:  ${chalk.cyan(template)}`);
+        logger.log(`  Config:    ${chalk.gray(".chainlesschain/config.json")}`);
+        logger.log(`  Rules:     ${chalk.gray(".chainlesschain/rules.md")}`);
+        logger.log(`  Skills:    ${chalk.gray(".chainlesschain/skills/")}`);
+        logger.log("");
+        logger.log(chalk.bold("Next steps:"));
+        logger.log(
+          `  ${chalk.cyan("chainlesschain skill add <name>")}  Create a custom project skill`,
+        );
+        logger.log(
+          `  ${chalk.cyan("chainlesschain skill list")}        List all available skills`,
+        );
+        logger.log(
+          `  ${chalk.cyan("chainlesschain agent")}             Start the AI agent`,
+        );
+        logger.log("");
+      } catch (err) {
+        logger.error(`Failed to initialize: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}