@jjlabsio/claude-crew 0.1.44 → 0.1.46

package/.claude-plugin/marketplace.json

@@ -11,7 +11,7 @@
       "name": "claude-crew",
       "source": "./",
       "description": "오케스트레이터 + PM, 플래너, 개발, QA, 마케팅 에이전트 팀으로 단일 제품의 개발과 마케팅을 통합 관리",
-      "version": "0.1.44",
+      "version": "0.1.46",
       "author": {
         "name": "Jaejin Song",
         "email": "wowlxx28@gmail.com"
@@ -28,5 +28,5 @@
       "category": "workflow"
     }
   ],
-  "version": "0.1.44"
+  "version": "0.1.46"
 }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-crew",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "1인 SaaS 개발자를 위한 멀티 에이전트 오케스트레이션 — 개발, 마케팅, 일정을 한 대화에서 통합 관리",
   "author": {
     "name": "Jaejin Song",

package/hooks/hooks.json

@@ -5,6 +5,11 @@
       {
         "matcher": "*",
         "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PLUGIN_ROOT/scripts/crew-session-restore.mjs\"",
+            "timeout": 5
+          },
           {
             "type": "command",
             "command": "node \"$CLAUDE_PLUGIN_ROOT/scripts/setup-hud.mjs\"",
@@ -13,6 +18,30 @@
         ]
       }
     ],
+    "PreCompact": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PLUGIN_ROOT/scripts/crew-pre-compact.mjs\"",
+            "timeout": 10
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PLUGIN_ROOT/scripts/crew-context-guard-stop.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "Agent|Task",

package/lib/crew-state.mjs

@@ -0,0 +1,72 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { basename, join } from "node:path";
+
+const STATE_VERSION = 1;
+const CURRENT_RUN_FILE = "current-run.json";
+
+export function currentRunPath(crewDir) {
+  return join(crewDir, "state", CURRENT_RUN_FILE);
+}
+
+export function checkpointsDir(crewDir) {
+  return join(crewDir, "state", "checkpoints");
+}
+
+export async function readRunState(crewDir) {
+  const path = currentRunPath(crewDir);
+  if (!existsSync(path)) return null;
+
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    throw new Error(`Failed to read crew run state at ${path}: ${error.message}`);
+  }
+}
+
+export async function writeRunState(crewDir, state) {
+  const stateDir = join(crewDir, "state");
+  await mkdir(stateDir, { recursive: true });
+
+  const nextState = {
+    ...state,
+    version: state.version ?? STATE_VERSION,
+    lastUpdatedAt: new Date().toISOString()
+  };
+
+  const destination = currentRunPath(crewDir);
+  const tempPath = join(
+    stateDir,
+    `.${CURRENT_RUN_FILE}.${process.pid}.${Date.now()}.tmp`
+  );
+
+  await writeFile(tempPath, `${JSON.stringify(nextState, null, 2)}\n`, "utf8");
+  await rename(tempPath, destination);
+  return nextState;
+}
+
+export async function createCheckpoint(crewDir) {
+  const state = await readRunState(crewDir);
+  if (!state) return null;
+
+  const dir = checkpointsDir(crewDir);
+  await mkdir(dir, { recursive: true });
+
+  const timestamp = new Date().toISOString().replace(/:/g, "-");
+  const checkpointPath = join(dir, `checkpoint-${timestamp}.json`);
+  await writeFile(checkpointPath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
+  return checkpointPath;
+}
+
+export async function getLatestCheckpoint(crewDir) {
+  const dir = checkpointsDir(crewDir);
+  if (!existsSync(dir)) return null;
+
+  const { readdir } = await import("node:fs/promises");
+  const files = (await readdir(dir))
+    .filter((file) => /^checkpoint-.+\.json$/.test(file))
+    .sort((a, b) => a.localeCompare(b));
+
+  if (files.length === 0) return null;
+  return join(dir, basename(files.at(-1)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jjlabsio/claude-crew",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "description": "1인 SaaS 개발자를 위한 멀티 에이전트 오케스트레이션 — 개발, 마케팅, 일정을 한 대화에서 통합 관리",
   "author": "Jaejin Song <wowlxx28@gmail.com>",
   "license": "MIT",
@@ -19,6 +19,7 @@
     ".claude-plugin/",
     "agents/",
     "data/",
+    "lib/",
     "skills/",
     "hooks/",
     "hud/",

package/scripts/crew-context-guard-stop.mjs

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+const BYPASS_REASONS = [
+  "context_limit",
+  "context_window",
+  "context_full",
+  "max_tokens",
+  "conversation_too_long",
+  "abort",
+  "cancel",
+  "interrupt",
+  "auth"
+];
+
+async function readStdin(timeoutMs = 3000) {
+  if (process.stdin.isTTY) return null;
+  return new Promise((resolve) => {
+    let data = "";
+    const timer = setTimeout(() => resolve(data || null), timeoutMs);
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => { data += chunk; });
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolve(data || null);
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+  });
+}
+
+function pass() {
+  return { continue: true };
+}
+
+function sessionId(event) {
+  return String(event.session_id || event.sessionId || event.session?.id || "unknown")
+    .replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
+
+function reasonText(event) {
+  return [
+    event.stop_reason,
+    event.stopReason,
+    event.reason,
+    event.error,
+    event.message
+  ].filter(Boolean).join(" ").toLowerCase();
+}
+
+function shouldBypass(event) {
+  const text = reasonText(event);
+  return BYPASS_REASONS.some((reason) => text.includes(reason));
+}
+
+function collectUsage(value, found = { inputTokens: null, contextWindow: null }) {
+  if (!value || typeof value !== "object") return found;
+
+  for (const [key, nested] of Object.entries(value)) {
+    const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (
+      ["inputtokens", "inputtoken", "tokensinput", "totalinputtokens"].includes(normalized)
+      && Number.isFinite(Number(nested))
+    ) {
+      found.inputTokens = Math.max(found.inputTokens ?? 0, Number(nested));
+    }
+    if (
+      ["contextwindow", "contextwindowsize", "contextlimit", "maxcontexttokens"].includes(normalized)
+      && Number.isFinite(Number(nested))
+    ) {
+      found.contextWindow = Math.max(found.contextWindow ?? 0, Number(nested));
+    }
+    collectUsage(nested, found);
+  }
+
+  return found;
+}
+
+function parseUsageFromText(text) {
+  const inputMatches = [...text.matchAll(/"?(?:input_tokens|inputTokens|inputToken|total_input_tokens)"?\s*[:=]\s*(\d+)/gi)];
+  const windowMatches = [...text.matchAll(/"?(?:context_window|contextWindow|context_limit|max_context_tokens)"?\s*[:=]\s*(\d+)/gi)];
+
+  return {
+    inputTokens: inputMatches.length > 0 ? Math.max(...inputMatches.map((match) => Number(match[1]))) : null,
+    contextWindow: windowMatches.length > 0 ? Math.max(...windowMatches.map((match) => Number(match[1]))) : null
+  };
+}
+
+async function usageFromTranscript(event) {
+  const transcriptPath = event.transcript_path || event.transcriptPath;
+  if (!transcriptPath || !existsSync(transcriptPath)) {
+    return { inputTokens: null, contextWindow: null };
+  }
+
+  try {
+    const text = await readFile(transcriptPath, "utf8");
+    return parseUsageFromText(text.slice(-128 * 1024));
+  } catch {
+    return { inputTokens: null, contextWindow: null };
+  }
+}
+
+async function usageFor(event) {
+  const fromEvent = collectUsage(event);
+  const fromTranscript = await usageFromTranscript(event);
+  return {
+    inputTokens: fromEvent.inputTokens ?? fromTranscript.inputTokens,
+    contextWindow: fromEvent.contextWindow ?? fromTranscript.contextWindow
+  };
+}
+
+function counterPath(id) {
+  return join(tmpdir(), `crew-stop-guard-${id}.json`);
+}
+
+async function readCount(id) {
+  const path = counterPath(id);
+  if (!existsSync(path)) return 0;
+  try {
+    const payload = JSON.parse(await readFile(path, "utf8"));
+    return Number(payload.count) || 0;
+  } catch {
+    return 0;
+  }
+}
+
+async function writeCount(id, count) {
+  await writeFile(
+    counterPath(id),
+    `${JSON.stringify({ count, updatedAt: new Date().toISOString() }, null, 2)}\n`,
+    "utf8"
+  );
+}
+
+function blockMessage(percent) {
+  return [
+    "Crew context guard: this session appears to be near the context window.",
+    `Estimated usage: ${Math.round(percent)}%.`,
+    "Run /compact before continuing so the crew workflow can checkpoint and preserve pending role, artifacts, and resume handles."
+  ].join("\n");
+}
+
+async function main() {
+  const raw = await readStdin();
+  if (!raw) {
+    console.log(JSON.stringify(pass()));
+    return;
+  }
+
+  let event;
+  try { event = JSON.parse(raw); } catch {
+    console.log(JSON.stringify(pass()));
+    return;
+  }
+
+  if (shouldBypass(event)) {
+    console.log(JSON.stringify(pass()));
+    return;
+  }
+
+  const { inputTokens, contextWindow } = await usageFor(event);
+  if (!inputTokens || !contextWindow) {
+    console.log(JSON.stringify(pass()));
+    return;
+  }
+
+  const percent = (inputTokens / contextWindow) * 100;
+  if (percent < 75 || percent >= 95) {
+    console.log(JSON.stringify(pass()));
+    return;
+  }
+
+  const id = sessionId(event);
+  const count = await readCount(id);
+  if (count >= 2) {
+    console.log(JSON.stringify(pass()));
+    return;
+  }
+
+  await writeCount(id, count + 1);
+  const message = blockMessage(percent);
+  console.log(JSON.stringify({
+    continue: true,
+    decision: "block",
+    reason: message,
+    systemMessage: message,
+    hookSpecificOutput: {
+      hookEventName: "Stop",
+      additionalContext: message
+    }
+  }));
+}
+
+main();

package/scripts/crew-pre-compact.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+import { relative, resolve } from "node:path";
+
+import { createCheckpoint, readRunState } from "../lib/crew-state.mjs";
+
+async function readStdin(timeoutMs = 3000) {
+  if (process.stdin.isTTY) return null;
+  return new Promise((resolveInput) => {
+    let data = "";
+    const timer = setTimeout(() => resolveInput(data || null), timeoutMs);
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => { data += chunk; });
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolveInput(data || null);
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      resolveInput(null);
+    });
+  });
+}
+
+function emptyResponse() {
+  return { continue: true };
+}
+
+function hookResponse(message) {
+  return {
+    continue: true,
+    systemMessage: message,
+    hookSpecificOutput: {
+      hookEventName: "PreCompact",
+      additionalContext: message
+    }
+  };
+}
+
+function formatPath(cwd, path) {
+  if (!path) return null;
+  if (!path.startsWith("/")) return path;
+  return relative(cwd, path) || ".";
+}
+
+function pendingText(state) {
+  return state.pendingStatus || state.pending || "none";
+}
+
+function buildMessage({ state, checkpointPath, cwd }) {
+  const artifacts = Array.isArray(state.artifactPaths) ? state.artifactPaths : [];
+  const handles = state.agentHandles && typeof state.agentHandles === "object"
+    ? Object.entries(state.agentHandles)
+    : [];
+
+  return [
+    "# Crew PreCompact Checkpoint",
+    "",
+    `Workflow: ${state.workflow || "unknown"}`,
+    `Phase: ${state.phase || "unknown"}`,
+    `Task: ${state.taskFile || state.taskId || "unknown"}`,
+    `Active role: ${state.activeRole || "unknown"}`,
+    `Pending: ${pendingText(state)}`,
+    `Checkpoint: ${formatPath(cwd, checkpointPath)}`,
+    "Artifacts:",
+    ...(artifacts.length > 0 ? artifacts.map((path) => `- ${path}`) : ["- none"]),
+    "Resume handles:",
+    ...(handles.length > 0 ? handles.map(([role, handle]) => `- ${role}: ${handle}`) : ["- none"]),
+    "",
+    "After compaction, inspect the checkpoint and continue from the pending phase unless the user's newest request overrides it."
+  ].join("\n");
+}
+
+async function main() {
+  const raw = await readStdin();
+  let event = {};
+  if (raw) {
+    try { event = JSON.parse(raw); } catch { /* ignore */ }
+  }
+
+  const cwd = resolve(event.cwd || process.cwd());
+  const crewDir = resolve(cwd, ".crew");
+
+  try {
+    const state = await readRunState(crewDir);
+    if (!state) {
+      console.log(JSON.stringify(emptyResponse()));
+      return;
+    }
+
+    const checkpointPath = await createCheckpoint(crewDir);
+    console.log(JSON.stringify(hookResponse(buildMessage({ state, checkpointPath, cwd }))));
+  } catch (error) {
+    console.log(JSON.stringify({
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "PreCompact",
+        additionalContext: `CREW checkpoint failed: ${error.message}`
+      }
+    }));
+  }
+}
+
+main();

package/scripts/crew-session-restore.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+
+import { getLatestCheckpoint, readRunState } from "../lib/crew-state.mjs";
+
+async function readStdin(timeoutMs = 3000) {
+  if (process.stdin.isTTY) return null;
+  return new Promise((resolveInput) => {
+    let data = "";
+    const timer = setTimeout(() => resolveInput(data || null), timeoutMs);
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => { data += chunk; });
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolveInput(data || null);
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timer);
+      resolveInput(null);
+    });
+  });
+}
+
+function emptyResponse() {
+  return { continue: true };
+}
+
+function hookResponse(message) {
+  return {
+    continue: true,
+    systemMessage: message,
+    hookSpecificOutput: {
+      hookEventName: "SessionStart",
+      additionalContext: message
+    }
+  };
+}
+
+function formatPath(cwd, path) {
+  if (!path) return null;
+  if (!path.startsWith("/")) return path;
+  return relative(cwd, path) || ".";
+}
+
+function pendingText(state) {
+  return state.pendingStatus || state.pending || "none";
+}
+
+function lastArtifact(state) {
+  if (state.pendingAgentResultPath) return state.pendingAgentResultPath;
+  if (Array.isArray(state.artifactPaths) && state.artifactPaths.length > 0) {
+    return state.artifactPaths.at(-1);
+  }
+  return "none";
+}
+
+async function readJson(path) {
+  return JSON.parse(await readFile(path, "utf8"));
+}
+
+async function findActiveState(crewDir) {
+  const current = await readRunState(crewDir);
+  if (current?.active) {
+    return { state: current, checkpointPath: await getLatestCheckpoint(crewDir) };
+  }
+
+  const checkpointPath = await getLatestCheckpoint(crewDir);
+  if (!checkpointPath || !existsSync(checkpointPath)) return null;
+
+  const checkpoint = await readJson(checkpointPath);
+  if (!checkpoint?.active) return null;
+  return { state: checkpoint, checkpointPath };
+}
+
+function buildMessage({ state, checkpointPath, cwd }) {
+  const checkpointLine = checkpointPath
+    ? formatPath(cwd, checkpointPath)
+    : "none";
+
+  return [
+    "<crew-session-restore>",
+    "Active crew workflow detected.",
+    "",
+    `Workflow: ${state.workflow || "unknown"}`,
+    `Phase: ${state.phase || "unknown"}`,
+    `Task: ${state.taskFile || state.taskId || "unknown"}`,
+    `Pending: ${pendingText(state)}`,
+    `Last artifact: ${lastArtifact(state)}`,
+    `Checkpoint: ${checkpointLine}`,
+    "",
+    "Treat this as prior-session context. Prioritize the user's newest request. Resume the crew workflow only if the user asks to continue.",
+    "</crew-session-restore>"
+  ].join("\n");
+}
+
+async function main() {
+  const raw = await readStdin();
+  let event = {};
+  if (raw) {
+    try { event = JSON.parse(raw); } catch { /* ignore */ }
+  }
+
+  const cwd = resolve(event.cwd || process.cwd());
+  const crewDir = resolve(cwd, ".crew");
+
+  try {
+    const active = await findActiveState(crewDir);
+    if (!active) {
+      console.log(JSON.stringify(emptyResponse()));
+      return;
+    }
+
+    console.log(JSON.stringify(hookResponse(buildMessage({ ...active, cwd }))));
+  } catch (error) {
+    console.log(JSON.stringify({
+      continue: true,
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: `CREW restore failed: ${error.message}`
+      }
+    }));
+  }
+}
+
+main();

package/scripts/lib/dispatch.mjs

@@ -1,7 +1,8 @@
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
+import { promisify } from "node:util";
 import { fileURLToPath } from "node:url";
 
 import { persistCrewArtifact, ArtifactPersistError } from "./artifacts.mjs";
@@ -11,6 +12,8 @@ import { renderPrompt } from "./render.mjs";
 const DEFAULT_COMPANION = fileURLToPath(
   new URL("../crew-codex-companion.mjs", import.meta.url)
 );
+const execFileAsync = promisify(execFile);
+const AUTO_GIT_DIFF = "AUTO_GIT_DIFF";
 const AGENT_RESULT_STATUSES = new Set([
   "complete",
   "blocked_on_user",
@@ -33,6 +36,70 @@ export function formatDispatchProviderGuardMessage(role, provider) {
   return `dispatch is for Codex provider only. Resolved provider for role '${role}' is '${provider}'. Use 'render' + Agent tool for Claude provider (see crew-agent-runner SKILL.md).`;
 }
 
+export async function resolveAutoGitDiffInputs(request, options = {}) {
+  if (!hasAutoGitDiffInput(request)) {
+    return request;
+  }
+
+  const diff =
+    options.diff ??
+    (await generateAutoGitDiff({ cwd: options.cwd ?? process.cwd() }));
+
+  return {
+    ...request,
+    inputs: request.inputs.map((item) => {
+      if (item?.content !== AUTO_GIT_DIFF) {
+        return item;
+      }
+
+      return {
+        ...item,
+        content: diff
+      };
+    })
+  };
+}
+
+export function hasAutoGitDiffInput(request) {
+  return Array.isArray(request?.inputs)
+    ? request.inputs.some((item) => item?.content === AUTO_GIT_DIFF)
+    : false;
+}
+
+export async function generateAutoGitDiff({ cwd = process.cwd() } = {}) {
+  await git(["rev-parse", "--is-inside-work-tree"], cwd);
+
+  const [staged, unstaged] = await Promise.all([
+    git(["diff", "--no-ext-diff", "--staged"], cwd),
+    git(["diff", "--no-ext-diff"], cwd)
+  ]);
+
+  const sections = [
+    ["staged", staged],
+    ["unstaged", unstaged]
+  ]
+    .filter(([, content]) => content.trim().length > 0)
+    .map(([label, content]) => `# git diff (${label})\n${content.trimEnd()}`);
+
+  if (sections.length > 0) {
+    return sections.join("\n\n");
+  }
+
+  try {
+    const previousCommitDiff = await git(
+      ["diff", "--no-ext-diff", "HEAD~1"],
+      cwd
+    );
+    if (previousCommitDiff.trim().length > 0) {
+      return `# git diff (HEAD~1)\n${previousCommitDiff.trimEnd()}`;
+    }
+  } catch {
+    // Repositories with fewer than two commits have no HEAD~1 fallback.
+  }
+
+  return "# git diff\nNo git diff available.";
+}
+
 export async function dispatch(input) {
   if (input.resolved?.provider !== "codex") {
     throw new DispatchError(
@@ -46,6 +113,7 @@ export async function dispatch(input) {
 
   const companion = resolveCompanion(input);
   await assertResumeCandidate(input.resumeHandle, companion);
+  const request = await resolveAutoGitDiffInputs(input.request);
 
   const tmpDir = await mkdtemp(join(tmpdir(), "claude-crew-dispatch-"));
   const promptFile = join(tmpDir, `${input.role}-prompt.md`);
@@ -55,7 +123,7 @@ export async function dispatch(input) {
       promptFile,
       renderPrompt({
         role: input.role,
-        request: input.request,
+        request,
         contract: input.contract
       }),
       "utf8"
@@ -137,6 +205,15 @@ export async function runCompanion(companion, args) {
   });
 }
 
+async function git(args, cwd) {
+  const { stdout } = await execFileAsync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 50 * 1024 * 1024
+  });
+  return stdout;
+}
+
 async function assertResumeCandidate(resumeHandle, companion) {
   if (!resumeHandle) {
     return;