buildcrew 1.8.7 → 1.9.1

package/lib/hook.js

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+/**
+ * Claude Code hook handler for buildcrew.
+ *
+ * Reads the CC hook JSON from stdin and does two things:
+ *   1. Prints a compact color-coded banner to the user's terminal so the
+ *      agent lifecycle is visible inline with the CC output.
+ *   2. Appends the event to .claude/buildcrew/events.jsonl so
+ *      `npx buildcrew watch` (or later tooling) can show a live view.
+ *
+ * Called as:   node dashboard/hooks/emit.js <kind>
+ * Kinds:       pre-agent | post-agent | file-written | user-prompt
+ *              | subagent-stop | session-end
+ *
+ * MUST be fast and MUST silent-fail (hooks block Claude Code if they hang).
+ */
+
+import { openSync, writeSync, closeSync, mkdirSync, appendFileSync } from "node:fs";
+import { join } from "node:path";
+
+const kind = process.argv[2];
+const EVENTS_PATH = join(process.cwd(), ".claude", "buildcrew", "events.jsonl");
+
+// ------------------------------------------------------------------
+// Terminal banner output — writes a compact styled line straight to
+// /dev/tty so it appears in the user's CC terminal regardless of how
+// the hook process's stdio is captured. NO_COLOR env disables ANSI.
+// ------------------------------------------------------------------
+const NO_COLOR = !!process.env.NO_COLOR || process.env.BUILDCREW_HOOK_QUIET === "1";
+const C = NO_COLOR
+  ? new Proxy({}, { get: () => "" })
+  : {
+      reset: "\x1b[0m",
+      bold:  "\x1b[1m",
+      dim:   "\x1b[2m",
+      red:   "\x1b[31m",
+      green: "\x1b[32m",
+      gold:  "\x1b[33m",
+      blue:  "\x1b[34m",
+      mag:   "\x1b[35m",
+      cyan:  "\x1b[36m",
+      gray:  "\x1b[90m",
+    };
+
+const AGENT_EMOJI = {
+  buildcrew: "🎩", planner: "📋", designer: "🎨", developer: "💻",
+  "qa-tester": "🧪", "browser-qa": "🌐", reviewer: "🧐", "health-checker": "🩺",
+  "security-auditor": "🛡", "canary-monitor": "🐤", shipper: "🚢",
+  thinker: "🤔", architect: "📐", "design-reviewer": "👀",
+  investigator: "🕵", "qa-auditor": "⚖",
+};
+
+function writeTTY(line) {
+  if (process.env.BUILDCREW_HOOK_QUIET === "1") return;
+  let fd;
+  try {
+    fd = openSync("/dev/tty", "w");
+    writeSync(fd, line + "\n");
+  } catch {
+    // No TTY (CI, pipe, etc.) — fall back to stderr
+    try { process.stderr.write(line + "\n"); } catch {}
+  } finally {
+    if (fd !== undefined) try { closeSync(fd); } catch {}
+  }
+}
+
+function banner(kind, data) {
+  switch (kind) {
+    case "pre-agent": {
+      const agent = data?.tool_input?.subagent_type ?? "agent";
+      const icon = AGENT_EMOJI[agent] ?? "●";
+      const prompt = truncate(data?.tool_input?.prompt ?? data?.tool_input?.description ?? "", 90);
+      return `${C.gold}▶${C.reset}  ${icon} ${C.bold}${agent}${C.reset} ${C.gray}· ${prompt}${C.reset}`;
+    }
+    case "post-agent": {
+      const agent = data?.tool_input?.subagent_type ?? "agent";
+      const icon = AGENT_EMOJI[agent] ?? "●";
+      return `${C.green}✓${C.reset}  ${icon} ${C.bold}${agent}${C.reset} ${C.gray}done${C.reset}`;
+    }
+    case "file-written": {
+      const p = data?.tool_input?.file_path;
+      if (!p) return null;
+      const rel = p.split("/").slice(-2).join("/");
+      return `${C.blue}📝${C.reset} ${rel} ${C.gray}(${data?.tool_name ?? "edit"})${C.reset}`;
+    }
+    case "session-end":
+      return `${C.mag}◼${C.reset}  ${C.dim}session ended${C.reset}`;
+    default:
+      return null; // user-prompt + subagent-stop are too noisy for terminal
+  }
+}
+
+async function main() {
+  if (!kind) process.exit(0);
+
+  // Read stdin (hooks send JSON on stdin)
+  let input = "";
+  try {
+    process.stdin.setEncoding("utf8");
+    for await (const chunk of process.stdin) input += chunk;
+  } catch {
+    process.exit(0);
+  }
+
+  let data = {};
+  if (input.trim()) {
+    try { data = JSON.parse(input); } catch { /* ignore malformed */ }
+  }
+
+  // Print styled banner to the user's terminal (this is the primary UX now —
+  // dashboard HTTP broadcast is optional and only works when server is up).
+  try {
+    const line = banner(kind, data);
+    if (line) writeTTY(line);
+  } catch {}
+
+  const events = toEvents(kind, data);
+  if (!events.length) process.exit(0);
+
+  // Append events to the JSONL log — silent-fail so hooks never block CC.
+  try {
+    mkdirSync(join(process.cwd(), ".claude", "buildcrew"), { recursive: true });
+    const lines = events
+      .map((e) => JSON.stringify({ ...e, at: e.at ?? new Date().toISOString() }))
+      .join("\n") + "\n";
+    appendFileSync(EVENTS_PATH, lines);
+  } catch {
+    // Disk full / permission — silently ignore; banner already printed.
+  }
+  process.exit(0);
+}
+
+function toEvents(kind, data) {
+  // Every event carries session_id so the dashboard can disambiguate
+  // concurrent Claude Code sessions running in the same project.
+  const sessionId = data?.session_id ?? "unknown";
+
+  switch (kind) {
+    case "pre-agent": {
+      const subagent = data?.tool_input?.subagent_type ?? "agent";
+      const prompt = truncate(data?.tool_input?.prompt ?? data?.tool_input?.description ?? "", 400);
+      return [{
+        type: "agent.dispatched",
+        agent: subagent, from: "buildcrew", prompt,
+        session_id: sessionId,
+      }];
+    }
+    case "post-agent": {
+      const subagent = data?.tool_input?.subagent_type ?? "agent";
+      const resp = data?.tool_response;
+      let summary = "";
+      if (typeof resp === "string") summary = resp.slice(0, 500);
+      else if (resp?.content?.[0]?.text) summary = String(resp.content[0].text).slice(0, 500);
+      return [{
+        type: "agent.completed",
+        agent: subagent, output_summary: summary,
+        session_id: sessionId,
+      }];
+    }
+    case "file-written": {
+      const path = data?.tool_input?.file_path;
+      if (!path) return [];
+      // CC hook payload doesn't include "current subagent" info. We default to
+      // "buildcrew" (team lead) so the dashboard HONESTLY reveals when the lead
+      // is writing files directly — which is a pipeline violation per Feature
+      // mode rules. Dashboard's pipeline-integrity check warns on this.
+      return [{
+        type: "file.written",
+        agent: data?.agent ?? "buildcrew", path,
+        tool_name: data?.tool_name,
+        session_id: sessionId,
+      }];
+    }
+    case "user-prompt": {
+      const sid = sessionId === "unknown" ? `cc-${Date.now()}` : sessionId;
+      const events = [{
+        type: "session.start",
+        session_id: sid,
+        mode: "feature",
+      }];
+      // CC's @mention invocations don't fire PreToolUse:Agent — they spawn
+      // subagents directly. Parse @<agent-name> from the prompt so the town
+      // shows a bubble when the user routes via @buildcrew (or any agent).
+      const prompt = String(data?.prompt ?? "");
+      const seen = new Set();
+      const mentionRe = /(?:^|\s)@([a-z][a-z0-9-]*)/gi;
+      let m;
+      while ((m = mentionRe.exec(prompt)) !== null) {
+        const name = m[1].toLowerCase();
+        if (seen.has(name)) continue;
+        seen.add(name);
+        events.push({
+          type: "agent.dispatched",
+          agent: name,
+          from: "user",
+          prompt: truncate(prompt, 400),
+          session_id: sid,
+        });
+      }
+      return events;
+    }
+    case "subagent-stop": {
+      // SubagentStop fires when an @-mention subagent finishes. CC's payload
+      // doesn't tell us which agent stopped, so we emit a sweep — the client
+      // idles every currently-active agent for this session.
+      return [{
+        type: "agent.completed",
+        agent: null,
+        sweep: true,
+        session_id: sessionId,
+      }];
+    }
+    case "session-end": {
+      return [{
+        type: "session.end",
+        session_id: sessionId,
+        outcome: "success",
+      }];
+    }
+    default:
+      return [];
+  }
+}
+
+function truncate(s, n) {
+  const t = String(s);
+  return t.length <= n ? t : t.slice(0, n - 1) + "…";
+}
+
+main();

package/lib/install-hooks.js

@@ -0,0 +1,165 @@
+/**
+ * buildcrew CC hook installer.
+ *
+ * Registers hook entries in .claude/settings.json that invoke
+ * `npx buildcrew-hook <kind>` on each agent/file event. The hook writes
+ * a styled banner to the terminal AND appends to events.jsonl so that
+ * `npx buildcrew watch` can show a live view in a separate pane.
+ *
+ * Idempotent — re-install replaces prior buildcrew entries without
+ * touching other hooks or permissions in the file.
+ */
+
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const BUILDCREW_TAG = "buildcrew-hook";
+
+export function resolveSettingsPath({ scope, cwd }) {
+  if (scope === "global") return path.join(os.homedir(), ".claude", "settings.json");
+  return path.join(cwd, ".claude", "settings.json");
+}
+
+export function resolvePermissionsPath({ scope, cwd }) {
+  if (scope === "global") return path.join(os.homedir(), ".claude", "settings.local.json");
+  return path.join(cwd, ".claude", "settings.local.json");
+}
+
+export function buildcrewHooks() {
+  const cmd = (kind) => `npx buildcrew-hook ${kind}`;
+  const mk = (kind, matcher) => ({
+    [BUILDCREW_TAG]: true,
+    ...(matcher ? { matcher } : {}),
+    hooks: [{ type: "command", command: cmd(kind) }],
+  });
+  return {
+    PreToolUse: [mk("pre-agent", "Agent")],
+    PostToolUse: [
+      mk("post-agent", "Agent"),
+      mk("file-written", "Write|Edit|MultiEdit"),
+    ],
+    UserPromptSubmit: [mk("user-prompt")],
+    Stop: [mk("session-end")],
+  };
+}
+
+export function buildcrewPermissions() {
+  return {
+    allow: [
+      "Agent", "Task", "Read", "Glob", "Grep", "Write", "Edit", "MultiEdit",
+      "NotebookEdit", "WebFetch", "WebSearch",
+      "Bash(npm *)", "Bash(npx *)", "Bash(node *)",
+      "Bash(git status*)", "Bash(git diff*)", "Bash(git log*)",
+      "Bash(git branch*)", "Bash(git show*)", "Bash(git add:*)", "Bash(git commit:*)",
+      "Bash(ls *)", "Bash(pwd)", "Bash(which *)",
+      "Bash(cat *)", "Bash(head *)", "Bash(tail *)",
+      "Bash(mkdir *)", "Bash(touch *)", "Bash(echo *)",
+    ],
+    deny: [
+      "Bash(rm -rf *)", "Bash(sudo *)",
+      "Bash(git push --force*)", "Bash(git reset --hard*)",
+      "Bash(curl * -X POST*)",
+    ],
+  };
+}
+
+export async function install({ scope = "project", cwd = process.cwd(), withPermissions = false } = {}) {
+  const settingsPath = resolveSettingsPath({ scope, cwd });
+  const { current, existed } = await readJson(settingsPath);
+  const next = mergeHooks(current, buildcrewHooks());
+
+  let permissionsResult = null;
+  if (withPermissions) {
+    permissionsResult = await installPermissions({ scope, cwd });
+  }
+
+  if (existed) await backup(settingsPath);
+  await atomicWrite(settingsPath, JSON.stringify(next, null, 2) + "\n");
+  return { action: "installed", settingsPath, existed, permissions: permissionsResult };
+}
+
+export async function installPermissions({ scope = "project", cwd = process.cwd() } = {}) {
+  const permPath = resolvePermissionsPath({ scope, cwd });
+  const { current, existed } = await readJson(permPath);
+  const rec = buildcrewPermissions();
+
+  const nextPerms = current.permissions && typeof current.permissions === "object"
+    ? { ...current.permissions } : {};
+  nextPerms.allow = mergeUnique(nextPerms.allow, rec.allow);
+  nextPerms.deny = mergeUnique(nextPerms.deny, rec.deny);
+
+  if (existed) await backup(permPath);
+  await atomicWrite(permPath, JSON.stringify({ ...current, permissions: nextPerms }, null, 2) + "\n");
+  return { action: "installed", permPath, existed };
+}
+
+export async function uninstall({ scope = "project", cwd = process.cwd() } = {}) {
+  const settingsPath = resolveSettingsPath({ scope, cwd });
+  const { current, existed } = await readJson(settingsPath);
+  if (!existed) return { action: "noop", reason: "no settings file", settingsPath };
+  const next = stripBuildcrewHooks(current);
+  await backup(settingsPath);
+  await atomicWrite(settingsPath, JSON.stringify(next, null, 2) + "\n");
+  return { action: "uninstalled", settingsPath };
+}
+
+// ------------ internals ------------
+
+async function readJson(p) {
+  try {
+    const buf = await fsp.readFile(p, "utf8");
+    return { current: JSON.parse(buf), existed: true };
+  } catch (err) {
+    if (err.code === "ENOENT") return { current: {}, existed: false };
+    throw new Error(`failed to read ${p}: ${err.message}`);
+  }
+}
+
+function mergeHooks(current, add) {
+  const out = { ...current };
+  const existing = out.hooks && typeof out.hooks === "object" ? { ...out.hooks } : {};
+  for (const [event, entries] of Object.entries(add)) {
+    const prev = Array.isArray(existing[event]) ? existing[event] : [];
+    // Remove prior buildcrew entries to stay idempotent
+    const filtered = prev.filter((e) => !(e && e[BUILDCREW_TAG]));
+    existing[event] = [...filtered, ...entries];
+  }
+  out.hooks = existing;
+  return out;
+}
+
+function stripBuildcrewHooks(current) {
+  const out = { ...current };
+  if (!out.hooks || typeof out.hooks !== "object") return out;
+  const cleaned = {};
+  for (const [event, entries] of Object.entries(out.hooks)) {
+    if (!Array.isArray(entries)) { cleaned[event] = entries; continue; }
+    const filtered = entries.filter((e) => !(e && e[BUILDCREW_TAG]));
+    if (filtered.length > 0) cleaned[event] = filtered;
+  }
+  if (Object.keys(cleaned).length === 0) delete out.hooks;
+  else out.hooks = cleaned;
+  return out;
+}
+
+function mergeUnique(existing, additions) {
+  const base = Array.isArray(existing) ? existing.slice() : [];
+  const seen = new Set(base);
+  for (const a of additions) if (!seen.has(a)) { base.push(a); seen.add(a); }
+  return base;
+}
+
+async function backup(p) {
+  try {
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    await fsp.copyFile(p, `${p}.buildcrew-backup-${ts}`);
+  } catch { /* best-effort */ }
+}
+
+async function atomicWrite(p, content) {
+  await fsp.mkdir(path.dirname(p), { recursive: true });
+  const tmp = `${p}.tmp-${process.pid}`;
+  await fsp.writeFile(tmp, content, "utf8");
+  await fsp.rename(tmp, p);
+}

package/package.json

@@ -1,16 +1,19 @@
 {
   "name": "buildcrew",
-  "version": "1.8.7",
+  "version": "1.9.1",
   "description": "15 AI agents for Claude Code — full development lifecycle from product thinking to production monitoring",
   "homepage": "https://buildcrew-landing.vercel.app",
   "author": "z1nun",
   "license": "MIT",
   "type": "module",
   "bin": {
-    "buildcrew": "./bin/setup.js"
+    "buildcrew": "./bin/setup.js",
+    "buildcrew-hook": "./bin/hook.js",
+    "buildcrew-watch": "./bin/watch.js"
   },
   "files": [
     "bin/",
+    "lib/",
     "agents/",
     "templates/",
     "README.md",
@@ -34,7 +37,8 @@
     "url": "https://github.com/z1nun/buildcrew.git"
   },
   "scripts": {
-    "test": "vitest run"
+    "test": "vitest run",
+    "watch": "node bin/watch.js"
   },
   "devDependencies": {
     "vitest": "^4.1.0"