@tekyzinc/gsd-t 3.29.11 → 4.0.12

package/scripts/hooks/gsd-t-conversation-capture.js

@@ -1,439 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-/**
- * GSD-T Conversation Capture Hook (M45 D2)
- *
- * Captures the orchestrator session's conversational turns into
- * `.gsd-t/transcripts/in-session-{sessionId}.ndjson` so the visualizer
- * left rail can list the in-session conversation alongside spawn entries.
- *
- * Installed into `~/.claude/settings.json` (SessionStart, UserPromptSubmit,
- * Stop, optional PostToolUse). Reads the hook payload from stdin, dispatches
- * on `hook_event_name`, appends a typed NDJSON frame. Writes content-level
- * data (not just tokens — that's the job of `gsd-t-in-session-usage-hook.js`).
- *
- * Safety:
- * - Never throws to the caller — catches all errors, logs to stderr, exits 0.
- * - `content` is capped at 16 KB per frame; over-cap writes `truncated: true`.
- * - Append-only; never overwrites an existing in-session NDJSON file.
- * - Project-dir discovery: prefers `GSD_T_PROJECT_DIR`, then decodes
- *   `payload.transcript_path`'s `~/.claude/projects/{slug}` to a real project
- *   root (session-specific signal — required when multiple parallel Claude
- *   Code sessions share one node-runtime hook process), then `payload.cwd`,
- *   then walks up from `process.cwd()` looking for `.gsd-t/progress.md`.
- *   Silent no-op if no project dir found.
- *
- * Contract: .gsd-t/contracts/conversation-capture-contract.md v1.2.0
- */
-
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-const os = require('os');
-
-const DEFAULT_SCRIPT_GUARD_MS = 5000;
-const CONTENT_CAP_BYTES = 16 * 1024; // 16 KB
-const MAX_STDIN = 1024 * 1024; // 1 MiB defense-in-depth
-const started = Date.now();
-
-function _readStdin() {
-  return new Promise((resolve) => {
-    let buf = '';
-    let aborted = false;
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => {
-      if (aborted) return;
-      buf += chunk;
-      if (buf.length > MAX_STDIN) {
-        aborted = true;
-        try { process.stdin.destroy(); } catch (_) { /* noop */ }
-        resolve('');
-      }
-    });
-    process.stdin.on('end', () => { if (!aborted) resolve(buf); });
-    process.stdin.on('error', () => resolve(buf));
-    setTimeout(() => resolve(buf), DEFAULT_SCRIPT_GUARD_MS).unref();
-  });
-}
-
-function _parsePayload(raw) {
-  try { return JSON.parse(raw || '{}'); } catch (_) { return null; }
-}
-
-function _walkUpForProject(startDir) {
-  try {
-    let dir = path.resolve(startDir || '.');
-    for (let i = 0; i < 10; i++) {
-      if (fs.existsSync(path.join(dir, '.gsd-t', 'progress.md'))) return dir;
-      const parent = path.dirname(dir);
-      if (parent === dir) break;
-      dir = parent;
-    }
-  } catch (_) { /* swallow */ }
-  return null;
-}
-
-// Decode a Claude Code project slug (the directory name under
-// `~/.claude/projects/`) back to an absolute project root that contains a
-// `.gsd-t/` directory. The slug encoding is lossy — `/` and literal `-` both
-// map to `-` — so we DFS-walk the filesystem, greedily consuming token runs as
-// directory names. First match whose `.gsd-t/` exists wins. Returns null if
-// nothing matches or the slug is malformed.
-//
-// Why this exists: Claude Code Stop hook payloads carry `transcript_path` =
-// `~/.claude/projects/{slug}/{sessionId}.jsonl`. The hook runs as one shared
-// node-runtime process across parallel Claude Code sessions, so `process.cwd()`
-// can resolve to the wrong project. The slug is the only *session-specific*
-// signal we have for project routing.
-function _slugToProjectDir(slug) {
-  if (typeof slug !== 'string' || slug.length === 0) return null;
-  if (slug[0] !== '-') return null; // must encode leading '/'
-  // Reject anything that could traversal-escape after decode.
-  if (slug.includes('/') || slug.includes('\\') || slug.includes('\0')) return null;
-  if (slug.includes('..')) return null;
-  const tokens = slug.slice(1).split('-'); // strip leading '-' (the leading '/')
-  if (tokens.length === 0 || tokens.some((t) => t.length === 0)) return null;
-  // DFS over how many '-'-separated tokens form each directory segment.
-  // Greedy preference: try fewest tokens first (most '/' separators) so deeper
-  // paths win when both interpretations exist.
-  function walk(prefix, idx) {
-    if (idx >= tokens.length) {
-      try {
-        if (fs.existsSync(path.join(prefix, '.gsd-t'))) return prefix;
-      } catch (_) { /* swallow */ }
-      return null;
-    }
-    for (let k = 1; k <= tokens.length - idx; k++) {
-      const seg = tokens.slice(idx, idx + k).join('-');
-      const next = path.join(prefix, seg);
-      // Re-validate after path.join — defense against weird inputs.
-      if (next.includes('..')) continue;
-      let exists = false;
-      try { exists = fs.existsSync(next); } catch (_) { exists = false; }
-      if (!exists) continue;
-      const found = walk(next, idx + k);
-      if (found) return found;
-    }
-    return null;
-  }
-  return walk('/', 0);
-}
-
-// Extract the slug ({dir-name} under `~/.claude/projects/`) from a
-// transcript_path. Returns null on malformed input.
-function _slugFromTranscriptPath(p) {
-  if (typeof p !== 'string' || !path.isAbsolute(p)) return null;
-  const home = process.env.HOME || os.homedir();
-  if (!home) return null;
-  const root = path.resolve(home, '.claude', 'projects') + path.sep;
-  const resolved = path.resolve(p);
-  if (!resolved.startsWith(root)) return null;
-  const rest = resolved.slice(root.length);
-  // First path segment after the projects/ root is the slug.
-  const sep = rest.indexOf(path.sep);
-  const slug = sep === -1 ? rest : rest.slice(0, sep);
-  if (!slug) return null;
-  return slug;
-}
-
-function _resolveProjectDir(payload) {
-  // 1. Explicit env override (preserved for tests + operator overrides).
-  const env = process.env.GSD_T_PROJECT_DIR;
-  if (env && fs.existsSync(path.join(env, '.gsd-t'))) return env;
-  // 2. Session-specific signal: decode the transcript_path slug. This is the
-  //    ONLY source that's per-session under parallel Claude Code instances —
-  //    cwd / walk-up resolve to whichever project the hook process happens to
-  //    inherit, which misroutes frames across projects.
-  if (payload && typeof payload.transcript_path === 'string') {
-    const slug = _slugFromTranscriptPath(payload.transcript_path);
-    if (slug) {
-      const fromSlug = _slugToProjectDir(slug);
-      if (fromSlug) return fromSlug;
-    }
-  }
-  // 3. payload.cwd (Claude Code may carry it on some events).
-  if (payload && typeof payload.cwd === 'string' && path.isAbsolute(payload.cwd)
-      && fs.existsSync(path.join(payload.cwd, '.gsd-t'))) {
-    return payload.cwd;
-  }
-  // 4. Last resort: walk up from process.cwd(). Known-unreliable for parallel
-  //    sessions sharing a node-runtime hook process — emit a one-line warning
-  //    so misroutes are diagnosable from stderr.
-  const walked = _walkUpForProject(process.cwd());
-  if (walked) {
-    try {
-      process.stderr.write(
-        'gsd-t-conversation-capture: project-dir resolved via cwd walk-up (' +
-        walked + ') — unreliable for parallel sessions\n'
-      );
-    } catch (_) { /* noop */ }
-    return walked;
-  }
-  return null;
-}
-
-function _resolveSessionId(payload) {
-  if (payload && typeof payload.session_id === 'string' && payload.session_id.length > 0
-      && !/[\/\\\0]|\.\./.test(payload.session_id)) {
-    return payload.session_id;
-  }
-  // Fallback: deterministic-ish per-process hash. Stable within one process,
-  // different across processes. Keeps the filename non-empty when Claude Code
-  // omits session_id (shouldn't happen in practice but we must not explode).
-  // Also used as defense-in-depth for malformed session_ids containing path
-  // separators / `..` that would let path.join collapse the `in-session-`
-  // prefix (protects the filename-prefix discriminator contract with the
-  // viewer + compact-detector).
-  const seed = String(process.pid) + ':' + String(started);
-  return 'pid-' + crypto.createHash('sha1').update(seed).digest('hex').slice(0, 12);
-}
-
-function _capContent(raw) {
-  if (raw == null) return { content: null, truncated: false };
-  let str;
-  if (typeof raw === 'string') str = raw;
-  else {
-    try { str = JSON.stringify(raw); } catch (_) { str = String(raw); }
-  }
-  const byteLen = Buffer.byteLength(str, 'utf8');
-  if (byteLen <= CONTENT_CAP_BYTES) return { content: str, truncated: false };
-  // Truncate by bytes; slice then re-decode to avoid breaking a multi-byte char.
-  const buf = Buffer.from(str, 'utf8').subarray(0, CONTENT_CAP_BYTES);
-  return { content: buf.toString('utf8'), truncated: true };
-}
-
-function _appendFrame(projectDir, sessionId, frame) {
-  const transcriptsDir = path.join(projectDir, '.gsd-t', 'transcripts');
-  try { fs.mkdirSync(transcriptsDir, { recursive: true }); } catch (_) { /* noop */ }
-  const outPath = path.join(transcriptsDir, 'in-session-' + sessionId + '.ndjson');
-  // Path-traversal guard: resolved path must stay under transcriptsDir.
-  const resolvedOut = path.resolve(outPath);
-  const resolvedDir = path.resolve(transcriptsDir) + path.sep;
-  if (!resolvedOut.startsWith(resolvedDir)) return;
-  fs.appendFileSync(outPath, JSON.stringify(frame) + '\n', 'utf8');
-}
-
-function _extractUserContent(payload) {
-  // Claude Code UserPromptSubmit payload carries the prompt text.
-  if (payload && typeof payload.prompt === 'string') return payload.prompt;
-  if (payload && payload.message && typeof payload.message.content === 'string') {
-    return payload.message.content;
-  }
-  if (payload && payload.user_message && typeof payload.user_message === 'string') {
-    return payload.user_message;
-  }
-  return null;
-}
-
-// Tail-read the last `bytes` of a file as UTF-8. Returns '' on any error.
-// Used so multi-MB transcripts don't get fully loaded into RAM.
-function _readFileTail(filePath, bytes) {
-  let fd = -1;
-  try {
-    const st = fs.statSync(filePath);
-    if (!st.isFile()) return '';
-    const size = st.size;
-    if (size === 0) return '';
-    const want = Math.min(bytes, size);
-    const start = size - want;
-    fd = fs.openSync(filePath, 'r');
-    const buf = Buffer.alloc(want);
-    fs.readSync(fd, buf, 0, want, start);
-    let str = buf.toString('utf8');
-    // If we sliced mid-line, drop the (possibly malformed) leading partial.
-    if (start > 0) {
-      const nl = str.indexOf('\n');
-      if (nl >= 0) str = str.slice(nl + 1);
-    }
-    return str;
-  } catch (_) {
-    return '';
-  } finally {
-    if (fd >= 0) { try { fs.closeSync(fd); } catch (_) { /* noop */ } }
-  }
-}
-
-// Validate `transcript_path` from a hook payload before reading. Stop hooks
-// from Claude Code put the file under `~/.claude/projects/`; we lock to that
-// to defeat path-traversal attempts (BUG-1 sanitizer pattern). Fail open
-// (return null) on anything suspicious.
-function _safeTranscriptPath(p) {
-  if (typeof p !== 'string' || p.length === 0) return null;
-  if (!path.isAbsolute(p)) return null;
-  const home = process.env.HOME || os.homedir();
-  if (!home) return null;
-  const allowedRoot = path.resolve(home, '.claude', 'projects') + path.sep;
-  const resolved = path.resolve(p);
-  if (!resolved.startsWith(allowedRoot)) return null;
-  return resolved;
-}
-
-// Pull the assistant body out of a Claude Code transcript JSONL by scanning
-// from the tail. Each line is one event; the latest `type === 'assistant'`
-// row carries the message. Concatenate all `text`-type content blocks; ignore
-// tool_use / tool_result / thinking blocks. Returns null if no assistant row
-// is found or every candidate is body-less (tool_use only).
-function _readAssistantFromTranscript(transcriptPath) {
-  const safe = _safeTranscriptPath(transcriptPath);
-  if (!safe) return null;
-  const tail = _readFileTail(safe, 64 * 1024);
-  if (!tail) return null;
-  const lines = tail.split('\n');
-  for (let i = lines.length - 1; i >= 0; i--) {
-    const line = lines[i];
-    if (!line) continue;
-    let row;
-    try { row = JSON.parse(line); } catch (_) { continue; }
-    if (!row || row.type !== 'assistant') continue;
-    // Skip subagent turns — orchestrator transcripts record both, but only
-    // the orchestrator's own assistant turn belongs in this in-session file.
-    if (row.isSidechain === true) continue;
-    const msg = row.message;
-    if (!msg) continue;
-    const blocks = msg.content;
-    if (typeof blocks === 'string') return blocks;
-    if (!Array.isArray(blocks)) continue;
-    const texts = [];
-    for (const b of blocks) {
-      if (b && b.type === 'text' && typeof b.text === 'string') texts.push(b.text);
-    }
-    if (texts.length === 0) continue; // tool_use-only turn — keep scanning
-    return texts.join('');
-  }
-  return null;
-}
-
-function _extractAssistantContent(payload) {
-  // PRIMARY: Claude Code Stop hook payload carries `transcript_path` to the
-  // orchestrator's JSONL. Read the most recent assistant row from the tail.
-  if (payload && typeof payload.transcript_path === 'string') {
-    const fromTranscript = _readAssistantFromTranscript(payload.transcript_path);
-    if (fromTranscript != null) return fromTranscript;
-  }
-  // Fallback shapes — kept so older / non-Claude-Code payload shapes still
-  // work (and so unit tests can exercise the hook without a real transcript).
-  if (payload && typeof payload.assistant_message === 'string') return payload.assistant_message;
-  if (payload && payload.message && typeof payload.message.content === 'string') {
-    return payload.message.content;
-  }
-  if (payload && typeof payload.content === 'string') return payload.content;
-  return null;
-}
-
-function _buildUserFrame(payload, sessionId, ts) {
-  const { content, truncated } = _capContent(_extractUserContent(payload));
-  const frame = {
-    type: 'user_turn',
-    ts,
-    session_id: sessionId,
-  };
-  if (content != null) frame.content = content;
-  if (truncated) frame.truncated = true;
-  if (payload && typeof payload.message_id === 'string') frame.message_id = payload.message_id;
-  return frame;
-}
-
-function _buildAssistantFrame(payload, sessionId, ts) {
-  const { content, truncated } = _capContent(_extractAssistantContent(payload));
-  const frame = {
-    type: 'assistant_turn',
-    ts,
-    session_id: sessionId,
-  };
-  if (content != null) frame.content = content;
-  if (truncated) frame.truncated = true;
-  if (payload && typeof payload.message_id === 'string') frame.message_id = payload.message_id;
-  return frame;
-}
-
-function _buildSessionStartFrame(sessionId, ts) {
-  return { type: 'session_start', ts, session_id: sessionId };
-}
-
-function _buildToolUseFrame(payload, sessionId, ts) {
-  const frame = {
-    type: 'tool_use',
-    ts,
-    session_id: sessionId,
-  };
-  if (payload && typeof payload.tool_name === 'string') frame.name = payload.tool_name;
-  else if (payload && payload.tool && typeof payload.tool.name === 'string') frame.name = payload.tool.name;
-  if (payload && typeof payload.tool_use_id === 'string') frame.tool_use_id = payload.tool_use_id;
-  if (payload && typeof payload.duration_ms === 'number') frame.duration_ms = payload.duration_ms;
-  return frame;
-}
-
-function _handle(payload) {
-  if (!payload || typeof payload !== 'object') return;
-  const event = payload.hook_event_name;
-  if (!event) return;
-
-  const projectDir = _resolveProjectDir(payload);
-  if (!projectDir) return; // not a GSD-T project — silent no-op
-
-  const sessionId = _resolveSessionId(payload);
-  const ts = new Date().toISOString();
-
-  switch (event) {
-    case 'SessionStart': {
-      _appendFrame(projectDir, sessionId, _buildSessionStartFrame(sessionId, ts));
-      return;
-    }
-    case 'UserPromptSubmit': {
-      _appendFrame(projectDir, sessionId, _buildUserFrame(payload, sessionId, ts));
-      return;
-    }
-    case 'Stop': {
-      _appendFrame(projectDir, sessionId, _buildAssistantFrame(payload, sessionId, ts));
-      return;
-    }
-    case 'PostToolUse': {
-      // Opt-in: guarded to keep default writes small.
-      if (process.env.GSD_T_CAPTURE_TOOL_USES !== '1') return;
-      _appendFrame(projectDir, sessionId, _buildToolUseFrame(payload, sessionId, ts));
-      return;
-    }
-    default:
-      return;
-  }
-}
-
-async function main() {
-  try {
-    const raw = await _readStdin();
-    const payload = _parsePayload(raw);
-    if (!payload) return;
-    _handle(payload);
-  } catch (err) {
-    try { process.stderr.write('gsd-t-conversation-capture: ' + (err && err.message || err) + '\n'); } catch (_) { /* noop */ }
-  } finally {
-    const elapsed = Date.now() - started;
-    if (elapsed > DEFAULT_SCRIPT_GUARD_MS) process.exitCode = 0;
-  }
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = {
-  _internal: {
-    _parsePayload,
-    _resolveProjectDir,
-    _resolveSessionId,
-    _capContent,
-    _buildUserFrame,
-    _buildAssistantFrame,
-    _buildSessionStartFrame,
-    _buildToolUseFrame,
-    _appendFrame,
-    _handle,
-    _extractAssistantContent,
-    _readAssistantFromTranscript,
-    _safeTranscriptPath,
-    _readFileTail,
-    _slugFromTranscriptPath,
-    _slugToProjectDir,
-    CONTENT_CAP_BYTES,
-  },
-};

package/scripts/hooks/gsd-t-in-session-usage-hook.js

@@ -1,84 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-/**
- * GSD-T In-Session Usage Hook (M43 D1-T2)
- *
- * Installed into `~/.claude/settings.json` (Stop + SessionEnd) to capture
- * per-turn token usage for the dialog channel. Reads the hook payload from
- * stdin, resolves the project directory from `payload.cwd`, then delegates to
- * `bin/gsd-t-in-session-usage.cjs::processHookPayload` which reads the
- * transcript at `payload.transcript_path` and appends schema-v2 rows to
- * `.gsd-t/metrics/token-usage.jsonl`.
- *
- * Silent on success (hooks run async in Claude Code — stdout is ignored).
- * Swallows every error: a flaky capture must never break the user's session.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const DEFAULT_SCRIPT_GUARD_MS = 5000;
-const started = Date.now();
-
-function _readStdin() {
-  return new Promise((resolve) => {
-    let buf = '';
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', chunk => { buf += chunk; });
-    process.stdin.on('end', () => resolve(buf));
-    process.stdin.on('error', () => resolve(buf));
-    setTimeout(() => resolve(buf), DEFAULT_SCRIPT_GUARD_MS).unref();
-  });
-}
-
-function _parsePayload(raw) {
-  try {
-    return JSON.parse(raw || '{}');
-  } catch (_) {
-    return null;
-  }
-}
-
-function _resolveProjectDir(payload) {
-  if (payload && payload.cwd && fs.existsSync(payload.cwd)) return payload.cwd;
-  if (process.cwd) return process.cwd();
-  return '.';
-}
-
-function _resolveInSessionModule(projectDir) {
-  const candidates = [
-    path.join(projectDir, 'bin', 'gsd-t-in-session-usage.cjs'),
-    path.join(process.env.HOME || '', '.claude', 'gsd-t', 'bin', 'gsd-t-in-session-usage.cjs'),
-  ];
-  for (const p of candidates) {
-    if (fs.existsSync(p)) return p;
-  }
-  return null;
-}
-
-async function main() {
-  try {
-    const raw = await _readStdin();
-    const payload = _parsePayload(raw);
-    if (!payload) return;
-    if (payload.hook_event_name !== 'Stop' && payload.hook_event_name !== 'SessionEnd') return;
-
-    const projectDir = _resolveProjectDir(payload);
-    const modulePath = _resolveInSessionModule(projectDir);
-    if (!modulePath) return;
-
-    const mod = require(modulePath);
-    mod.processHookPayload({ projectDir, payload });
-  } catch (_) {
-    // Intentionally swallow — hook must never interrupt the user session.
-  } finally {
-    const elapsed = Date.now() - started;
-    if (elapsed > DEFAULT_SCRIPT_GUARD_MS) process.exitCode = 0;
-  }
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = { _internal: { _parsePayload, _resolveProjectDir } };

package/scripts/spawn-plan-fmt-tokens.cjs

@@ -1,80 +0,0 @@
-'use strict';
-
-/**
- * GSD-T Spawn Plan — token formatting + cumulative totals (M44 D8 T7)
- *
- * Pure helper module used by the transcript right-side spawn-plan panel.
- * Extracted from the inline script in `scripts/gsd-t-transcript.html` so the
- * same functions can be unit-tested under Node without loading a DOM.
- *
- * Contract: .gsd-t/contracts/spawn-plan-contract.md v1.0.0
- *   - Token cell format: `in=12.5k out=1.7k $0.42` (k-suffix above 1000,
- *     2-decimal USD). Returns `—` when tokens are null/missing.
- *   - Cumulative totals: sum `{in,out,cr,cc,cost_usd}` across done tasks.
- *     Returns `null` when no done-task has tokens (panel renders `—`).
- *
- * Zero external deps. `.cjs` so it loads in both ESM-default and CJS projects.
- */
-
-/**
- * k-suffix number formatter. `1500` → `1.5k`, `999` → `999`, `null` → `0`.
- * Used by `fmtTokens` to compact large counts.
- *
- * @param {number|string|null|undefined} n
- * @returns {string}
- */
-function fmtK(n) {
-  if (n == null || Number.isNaN(Number(n))) return '0';
-  const num = Number(n);
-  if (Math.abs(num) >= 1000) return (num / 1000).toFixed(1) + 'k';
-  return String(num);
-}
-
-/**
- * Render a token-cell string from a `{in, out, cr, cc, cost_usd}` object.
- * When `tokens` is null/undefined/non-object, returns the em-dash marker
- * per the "zero is a measurement, dash is acknowledged gap" rule.
- *
- * @param {object|null|undefined} tokens
- * @returns {string}
- */
-function fmtTokens(tokens) {
-  if (!tokens || typeof tokens !== 'object') return '—';
-  const ins = fmtK(tokens.in);
-  const out = fmtK(tokens.out);
-  const cost = (typeof tokens.cost_usd === 'number')
-    ? '$' + tokens.cost_usd.toFixed(2)
-    : '';
-  return ['in=' + ins, 'out=' + out, cost].filter(Boolean).join(' ');
-}
-
-/**
- * Sum the `tokens` field across every task whose `status === 'done'` and
- * whose `tokens` is a populated object. Returns null when no done-task has
- * a tokens object attached — the panel renders that state as `—`.
- *
- * @param {Array<{status?:string, tokens?:object}>|null|undefined} tasks
- * @returns {{in:number,out:number,cr:number,cc:number,cost_usd:number}|null}
- */
-function sumTokens(tasks) {
-  const acc = { in: 0, out: 0, cr: 0, cc: 0, cost_usd: 0 };
-  let hit = false;
-  for (const t of (tasks || [])) {
-    if (!t || t.status !== 'done' || !t.tokens) continue;
-    acc.in += Number(t.tokens.in || 0);
-    acc.out += Number(t.tokens.out || 0);
-    acc.cr += Number(t.tokens.cr || 0);
-    acc.cc += Number(t.tokens.cc || 0);
-    acc.cost_usd += Number(t.tokens.cost_usd || 0);
-    hit = true;
-  }
-  if (!hit) return null;
-  acc.cost_usd = Math.round(acc.cost_usd * 100) / 100;
-  return acc;
-}
-
-module.exports = {
-  fmtK,
-  fmtTokens,
-  sumTokens,
-};

package/templates/hooks/post-commit-spawn-plan.sh

@@ -1,85 +0,0 @@
-#!/usr/bin/env bash
-# GSD-T Post-Commit Spawn-Plan Hook — installed by `gsd-t init`
-#
-# This is a thin shim that delegates to the canonical hook script
-# shipped with GSD-T. If your project doesn't yet have the canonical
-# script, this template copy handles commits by itself; once the
-# framework script is in place, the framework wins.
-#
-# Contract: .gsd-t/contracts/spawn-plan-contract.md v1.0.0
-
-set +e  # silent-fail — never break the commit
-
-PROJECT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)"
-if [ -z "$PROJECT_DIR" ] || [ ! -d "$PROJECT_DIR/.gsd-t/spawns" ]; then
-  exit 0
-fi
-
-CANONICAL="$PROJECT_DIR/scripts/gsd-t-post-commit-spawn-plan.sh"
-if [ -x "$CANONICAL" ]; then
-  # Delegate to the framework-shipped hook.
-  "$CANONICAL"
-  exit 0
-fi
-
-UPDATER="$PROJECT_DIR/bin/spawn-plan-status-updater.cjs"
-if [ ! -f "$UPDATER" ]; then
-  exit 0
-fi
-
-if ! command -v node >/dev/null 2>&1; then
-  echo "[spawn-plan-hook] node not found — skipping" 1>&2
-  exit 0
-fi
-
-COMMIT_SHA="$(git rev-parse --short HEAD 2>/dev/null)"
-COMMIT_MSG="$(git log -1 --format=%B 2>/dev/null)"
-if [ -z "$COMMIT_SHA" ] || [ -z "$COMMIT_MSG" ]; then
-  exit 0
-fi
-
-TASK_IDS="$(printf '%s' "$COMMIT_MSG" | grep -oE '\[M[0-9]+-D[0-9]+-T[0-9]+\]' | sed 's/[][]//g' | awk '!seen[$0]++')"
-if [ -z "$TASK_IDS" ]; then
-  exit 0
-fi
-
-printf '%s\n' "$TASK_IDS" | node -e '
-"use strict";
-try {
-  const path = require("path");
-  const fs = require("fs");
-  const projectDir = process.argv[1];
-  const commit = process.argv[2];
-  let raw = "";
-  process.stdin.setEncoding("utf8");
-  process.stdin.on("data", (c) => { raw += c; });
-  process.stdin.on("end", () => {
-    try {
-      const taskIds = raw.split("\n").map((s) => s.trim()).filter(Boolean);
-      if (!taskIds.length) process.exit(0);
-      const updater = require(path.join(projectDir, "bin", "spawn-plan-status-updater.cjs"));
-      const activePaths = updater.listActivePlans(projectDir);
-      if (!activePaths.length) process.exit(0);
-      for (const fp of activePaths) {
-        let plan;
-        try { plan = JSON.parse(fs.readFileSync(fp, "utf8")); } catch (_) { continue; }
-        const spawnId = plan && plan.spawnId;
-        const spawnStartedAt = plan && plan.startedAt;
-        if (!spawnId) continue;
-        const planTaskIds = new Set((plan.tasks || []).map((t) => t && t.id).filter(Boolean));
-        for (const taskId of taskIds) {
-          if (!planTaskIds.has(taskId)) continue;
-          const tokens = updater.sumTokensForTask({ projectDir, taskId, spawnStartedAt });
-          updater.markTaskDone({ spawnId, taskId, commit, tokens, projectDir });
-        }
-      }
-    } catch (err) {
-      try { process.stderr.write("[spawn-plan-hook] " + String(err && err.message || err) + "\n"); } catch (_) { /* silent */ }
-    }
-  });
-} catch (err) {
-  try { process.stderr.write("[spawn-plan-hook] " + String(err && err.message || err) + "\n"); } catch (_) { /* silent */ }
-}
-' "$PROJECT_DIR" "$COMMIT_SHA" 2>/dev/null
-
-exit 0