@nocville/npc 0.0.0-stage → 0.2.0

package/dist/npcs/agent-common/git-stats.js

@@ -0,0 +1,67 @@
+import { spawnSync } from 'node:child_process';
+import { basename } from 'node:path';
+import { performance } from 'node:perf_hooks';
+/** Parse NUL-delimited numstat, including binary files and rename path pairs. */
+export function parseNumstat(raw) {
+    const fields = raw.split('\0'), files = [];
+    for (let i = 0; i < fields.length; i++) {
+        const record = fields[i];
+        if (!record)
+            continue;
+        const match = /^(\d+|-)\t(\d+|-)\t([\s\S]*)$/.exec(record);
+        if (!match)
+            continue;
+        let path = match[3];
+        if (!path) {
+            i++;
+            path = fields[++i] ?? '';
+        }
+        if (path)
+            files.push({
+                path,
+                insertions: match[1] === '-' ? 0 : Number(match[1]),
+                deletions: match[2] === '-' ? 0 : Number(match[2]),
+            });
+    }
+    return files;
+}
+/** Both commands share one wall-clock budget; call only from detached flushes. */
+export function computeGitStats(cwd, timeoutMs = 1500) {
+    const deadline = performance.now() + Math.max(1, Math.min(1500, timeoutMs));
+    const git = (args) => {
+        const remaining = Math.floor(deadline - performance.now());
+        if (remaining <= 0)
+            return null;
+        const result = spawnSync('git', ['--no-optional-locks', '-c', 'core.fsmonitor=false', '-C', cwd, ...args], {
+            encoding: 'utf8',
+            timeout: remaining,
+            killSignal: 'SIGKILL',
+            maxBuffer: 1 << 20,
+            windowsHide: true,
+        });
+        return result.status === 0 && !result.error ? result.stdout : null;
+    };
+    const diff = git(['diff', '--no-ext-diff', '--no-textconv', '--numstat', '-z', 'HEAD', '--']);
+    if (diff === null)
+        return null;
+    const untracked = git(['ls-files', '--others', '--exclude-standard', '-z']);
+    if (untracked === null)
+        return null;
+    const files = parseNumstat(diff);
+    for (const path of untracked.split('\0'))
+        if (path)
+            files.push({ path, insertions: 0, deletions: 0 });
+    if (files.length > 100_000)
+        return null;
+    files.sort((a, b) => b.insertions + b.deletions - (a.insertions + a.deletions) || a.path.localeCompare(b.path));
+    return {
+        filesChanged: files.length,
+        insertions: files.reduce((n, file) => n + file.insertions, 0),
+        deletions: files.reduce((n, file) => n + file.deletions, 0),
+        lastFiles: files.slice(0, 5).map((file) => basename(file.path)
+            // eslint-disable-next-line no-control-regex -- Strip display controls from Git filenames.
+            .replace(/[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]/g, '')
+            .slice(0, 120)),
+    };
+}
+//# sourceMappingURL=git-stats.js.map

package/dist/npcs/agent-common/hook-runner.d.ts

@@ -0,0 +1,62 @@
+import type { StatusUpdate } from '@nocville/node';
+import type { NpcConfig } from '../../core/types.js';
+import { computeGitStats } from './git-stats.js';
+import type { AgentAdapter, AgentSessionState, AgentTransition } from './session.js';
+/** A raw hook payload (Claude Code and Codex share the same envelope shape). */
+export interface AgentHookEvent {
+    session_id?: string;
+    hook_event_name?: string;
+    /** Legacy alias accepted by older callers/tests. */
+    event?: string;
+    cwd?: string;
+    tool_name?: string;
+    tool_input?: unknown;
+    [key: string]: unknown;
+}
+export declare function hookEventName(event: AgentHookEvent): string;
+/** Everything that differs between agents. */
+export interface AgentHookSpec {
+    adapter: AgentAdapter;
+    /** Required neutral response for hosts whose hook protocol always expects JSON. */
+    stdoutOnSuccess?: string;
+    statsEvents?: readonly string[];
+    /** Cross-source pairs (native and imported hooks), deduplicated under the state lock. */
+    deliveryIdentity?(event: AgentHookEvent): {
+        key: string;
+        source: string;
+    };
+    serviceIdFor(sessionId: string, cwd: string): string;
+    transition(event: AgentHookEvent, prev: AgentSessionState | null): AgentTransition;
+    /** Optional user-facing session name (e.g. Claude Code session title). */
+    resolveName?(event: AgentHookEvent, prev: AgentSessionState | null): string | undefined;
+}
+export interface HookRunOptions {
+    /**
+     * 'inline' awaits the push in-process (library use, tests). 'detach' (the CLI
+     * default) hands pushes to a background process so the hook exits at once.
+     */
+    mode?: 'inline' | 'detach';
+    minPushGapMs?: number;
+    now?: () => number;
+    /** Inline-mode push override (tests). */
+    push?: (serviceId: string, payload: StatusUpdate) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /** Override how deferred flushes are scheduled (tests). */
+    scheduleFlush?: (sessionId: string, delayMs: number) => void;
+    /** cli.js path for detached flushes (default: process.argv[1]). */
+    cliPath?: string;
+}
+/** Read all of stdin synchronously; '' on error. */
+export declare function readStdin(): string;
+/**
+ * Process one hook invocation. Never throws. Only a configured neutral JSON response
+ * reaches stdout; other hosts receive no output.
+ */
+export declare function runAgentHook(spec: AgentHookSpec, config: NpcConfig, rawInput: string | AgentHookEvent, opts?: HookRunOptions): Promise<void>;
+/** `<agent> flush <session> --delay=ms`: the detached half of a hook push. */
+export declare function runFlushCommand(adapter: AgentAdapter, config: NpcConfig, sessionId: string | undefined, delayMs: number | undefined, stats?: boolean): Promise<void>;
+/** Git runs outside the state lock, and a newer turn can invalidate its result. */
+export declare function collectSessionGitStats(adapter: AgentAdapter, sessionId: string, compute?: typeof computeGitStats): Promise<void>;
+//# sourceMappingURL=hook-runner.d.ts.map

package/dist/npcs/agent-common/hook-runner.js

@@ -0,0 +1,245 @@
+import { readFileSync } from 'node:fs';
+import { describeToolUse } from './activity.js';
+import { computeGitStats } from './git-stats.js';
+import { resolveAgentPid, reserveAgentPidAttempt } from './liveness.js';
+import { withStateLock } from './lock.js';
+import { applySubagentEvent, pushHistory, maybeCleanupSessionStates, stateFilePath, applyTransition, flushSession, readSessionState, sleep, spawnDetachedFlush, writeSessionState, DEFAULT_MIN_PUSH_GAP_MS, } from './session.js';
+import { ensureWatchdog } from './watchdog.js';
+export function hookEventName(event) {
+    return event.hook_event_name ?? event.event ?? '';
+}
+/** Read all of stdin synchronously; '' on error. */
+export function readStdin() {
+    try {
+        return readFileSync(0, 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Process one hook invocation. Never throws. Only a configured neutral JSON response
+ * reaches stdout; other hosts receive no output.
+ */
+export async function runAgentHook(spec, config, rawInput, opts = {}) {
+    try {
+        await runAgentHookUnsafe(spec, config, rawInput, opts);
+    }
+    catch (err) {
+        if (config.debug) {
+            console.error(`[nocville ${spec.adapter.command} hook] ${err?.message ?? err}`);
+        }
+    }
+    finally {
+        if (spec.stdoutOnSuccess !== undefined)
+            process.stdout.write(spec.stdoutOnSuccess + '\n');
+    }
+}
+async function runAgentHookUnsafe(spec, config, rawInput, opts) {
+    if (typeof rawInput === 'string' && !rawInput.trim())
+        return;
+    let event;
+    try {
+        event = typeof rawInput === 'string' ? JSON.parse(rawInput) : rawInput;
+    }
+    catch {
+        return;
+    }
+    if (!event || typeof event !== 'object')
+        return;
+    const sessionId = typeof event.session_id === 'string' ? event.session_id : '';
+    if (!sessionId)
+        return;
+    const { adapter } = spec;
+    const eventName = hookEventName(event);
+    // Leave headroom for launcher startup and the 1.5s HTTP attempt within Codex's 3s cap.
+    const shutdown = eventName === 'SessionEnd' || eventName === 'Interrupt';
+    const lockWaitMs = shutdown ? 150 : adapter.family === 'gemini' ? 500 : undefined;
+    const canResolvePid = adapter.processNames?.length !== 0 &&
+        !shutdown &&
+        opts.mode === 'detach' &&
+        process.env['NOCVILLE_NO_WATCHDOG'] !== '1';
+    const now = (opts.now ?? Date.now)();
+    if (eventName === 'SessionStart')
+        await maybeCleanupSessionStates(adapter.stateDir, now);
+    const { decision, offline, resolvePid, collectStats } = await withStateLock(stateFilePath(adapter.stateDir, sessionId), () => {
+        const prev = readSessionState(adapter.stateDir, sessionId);
+        if (prev && adapter.processNames?.length === 0 && (prev.agentPid || prev.watchdogPid)) {
+            // Retire observers installed before an adapter opted out of process liveness.
+            prev.agentPid = undefined;
+            prev.agentStartedAt = undefined;
+            prev.watchdogPid = undefined;
+            writeSessionState(adapter.stateDir, prev);
+        }
+        const identity = spec.deliveryIdentity?.(event);
+        const deliveries = (prev?.hookDeliveries ?? []).filter((d) => now - d.at < 5000);
+        if (identity) {
+            const duplicate = deliveries.findIndex((d) => d.key === identity.key && d.source !== identity.source);
+            if (duplicate >= 0 && prev) {
+                deliveries.splice(duplicate, 1);
+                prev.hookDeliveries = deliveries;
+                writeSessionState(adapter.stateDir, prev);
+                return {
+                    decision: { kind: 'none' },
+                    offline: !!prev.offline,
+                    resolvePid: false,
+                    collectStats: false,
+                };
+            }
+            deliveries.push({ ...identity, at: now });
+        }
+        const cwd = (typeof event.cwd === 'string' && event.cwd) || prev?.projectDir || process.cwd();
+        // An offline sentinel awaiting retry cannot be revived by late async tool hooks.
+        if (prev?.offline && eventName !== 'SessionStart')
+            return {
+                decision: { kind: 'now' },
+                offline: true,
+                resolvePid: false,
+                collectStats: false,
+            };
+        const agentId = typeof event['agent_id'] === 'string' ? event['agent_id'] : '';
+        if (adapter.family === 'claude' &&
+            agentId &&
+            prev &&
+            eventName !== 'PermissionRequest' &&
+            eventName !== 'SubagentStart') {
+            const next = applySubagentEvent(prev, agentId, typeof event['agent_type'] === 'string' ? event['agent_type'] : 'subagent', eventName, describeToolUse(event.tool_name, event.tool_input, cwd), now);
+            let decision = { kind: 'none' };
+            if (next.rev !== prev.rev) {
+                const gap = opts.minPushGapMs ?? DEFAULT_MIN_PUSH_GAP_MS;
+                const elapsed = now - (prev.lastPushAt ?? 0);
+                if (!prev.lastPushAt || elapsed >= gap) {
+                    next.lastPushAt = now;
+                    decision = { kind: 'now' };
+                }
+                else if (!next.flushAt || next.flushAt <= now - 2000) {
+                    const delayMs = Math.max(50, gap - elapsed);
+                    next.flushAt = now + delayMs;
+                    decision = { kind: 'defer', delayMs };
+                }
+            }
+            const resolvePid = canResolvePid && reserveAgentPidAttempt(next, now);
+            writeSessionState(adapter.stateDir, next);
+            return { decision, offline: false, resolvePid, collectStats: false };
+        }
+        // Codex has no documented agent_id in hook payloads: keep its parent transitions.
+        // https://developers.openai.com/codex/hooks
+        const { next, decision } = applyTransition(prev, {
+            sessionId,
+            serviceId: spec.serviceIdFor(sessionId, cwd),
+            projectDir: cwd,
+            eventName,
+            name: spec.resolveName?.(event, prev),
+            transition: spec.transition(event, prev),
+            now,
+        }, opts.minPushGapMs ?? DEFAULT_MIN_PUSH_GAP_MS);
+        if (!prev || prev.offline) {
+            next.agentPid = undefined;
+            next.agentStartedAt = undefined;
+            next.agentPidResolveAttempts = 0;
+            next.agentPidLastResolveAt = undefined;
+            next.watchdogPid = undefined;
+            next.offlineRetryStartedAt = undefined;
+            next.offlineDeliveryStopped = undefined;
+            next.subagents = {};
+            next.agentStats = undefined;
+            next.statsPendingRev = undefined;
+        }
+        if (identity)
+            next.hookDeliveries = deliveries.slice(-64);
+        const resolvePid = canResolvePid && reserveAgentPidAttempt(next, now);
+        const collectStats = (spec.statsEvents ?? ['Stop']).includes(eventName) && !next.offline;
+        if (collectStats)
+            next.statsPendingRev = next.rev ?? 0;
+        else if (next.state === 'WORKING' || next.offline)
+            next.statsPendingRev = undefined;
+        writeSessionState(adapter.stateDir, next);
+        return { decision, offline: !!next.offline, resolvePid, collectStats };
+    }, lockWaitMs);
+    if (resolvePid && !offline) {
+        const proc = resolveAgentPid(adapter, sessionId);
+        await withStateLock(stateFilePath(adapter.stateDir, sessionId), () => {
+            const fresh = readSessionState(adapter.stateDir, sessionId);
+            if (!fresh || fresh.offline)
+                return;
+            fresh.agentPid = proc?.pid;
+            fresh.agentStartedAt = proc?.startedAt;
+            writeSessionState(adapter.stateDir, fresh);
+        }, lockWaitMs);
+    }
+    if (opts.mode === 'detach' && !offline)
+        await ensureWatchdog(adapter, config, sessionId, opts.cliPath, lockWaitMs);
+    // SessionEnd is synchronous and bounded by the agent's short shutdown timeout.
+    if (offline) {
+        await flushSession(adapter, config, sessionId, {
+            push: opts.push,
+            timeoutMs: 1500,
+            lockWaitMs: 150,
+        });
+        // If delivery failed, the watchdog retries; unsupported hosts get one detached retry.
+        const pending = readSessionState(adapter.stateDir, sessionId);
+        if (opts.mode === 'detach' && pending && (pending.rev ?? 0) > (pending.pushedRev ?? 0))
+            spawnDetachedFlush(adapter, config, sessionId, 0, opts.cliPath);
+        return;
+    }
+    if (decision.kind === 'none' && !collectStats)
+        return;
+    const mode = opts.mode ?? 'inline';
+    const delayMs = decision.kind === 'defer' ? decision.delayMs : 0;
+    if (opts.scheduleFlush && decision.kind === 'defer') {
+        opts.scheduleFlush(sessionId, delayMs);
+        return;
+    }
+    if (mode === 'detach') {
+        spawnDetachedFlush(adapter, config, sessionId, delayMs, opts.cliPath, collectStats);
+        return;
+    }
+    if (delayMs > 0) {
+        const timer = setTimeout(() => {
+            void flushSession(adapter, config, sessionId, { push: opts.push });
+        }, delayMs);
+        timer.unref?.();
+        return;
+    }
+    await flushSession(adapter, config, sessionId, { push: opts.push });
+}
+/** `<agent> flush <session> --delay=ms`: the detached half of a hook push. */
+export async function runFlushCommand(adapter, config, sessionId, delayMs, stats = false) {
+    if (!sessionId)
+        return;
+    try {
+        if (delayMs && delayMs > 0)
+            await sleep(Math.min(delayMs, 10_000));
+        if (stats || readSessionState(adapter.stateDir, sessionId)?.statsPendingRev !== undefined)
+            await collectSessionGitStats(adapter, sessionId);
+        await flushSession(adapter, config, sessionId);
+    }
+    catch {
+        // never surface errors from a background flush
+    }
+}
+/** Git runs outside the state lock, and a newer turn can invalidate its result. */
+export async function collectSessionGitStats(adapter, sessionId, compute = computeGitStats) {
+    const snapshot = readSessionState(adapter.stateDir, sessionId);
+    if (!snapshot || snapshot.offline || snapshot.state === 'WORKING')
+        return;
+    // Another scheduled flush may already have consumed an explicit --stats request.
+    if (snapshot.statsPendingRev === undefined)
+        return;
+    const revision = snapshot.statsPendingRev;
+    const stats = compute(snapshot.projectDir);
+    await withStateLock(stateFilePath(adapter.stateDir, sessionId), () => {
+        const fresh = readSessionState(adapter.stateDir, sessionId);
+        if (!fresh || fresh.offline || fresh.state === 'WORKING' || fresh.statsPendingRev !== revision)
+            return;
+        fresh.statsPendingRev = undefined;
+        fresh.agentStats = stats ?? undefined;
+        if (stats && stats.filesChanged > 0) {
+            const line = `Uncommitted changes — ${stats.filesChanged} file${stats.filesChanged === 1 ? '' : 's'}, +${stats.insertions}/−${stats.deletions}`;
+            fresh.activity = pushHistory(fresh.activity, line);
+        }
+        fresh.rev = (fresh.rev ?? 0) + 1;
+        writeSessionState(adapter.stateDir, fresh);
+    });
+}
+//# sourceMappingURL=hook-runner.js.map

package/dist/npcs/agent-common/hook-settings.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Matcher-group hook config shared by Claude Code (`~/.claude/settings.json`)
+ * and Codex (`~/.codex/hooks.json`) — both use:
+ *
+ *   { "hooks": { "<Event>": [ { "matcher": "", "hooks": [ { "type": "command", "command": "…" } ] } ] } }
+ *
+ * Install/uninstall only ever touch entries whose command carries the
+ * `nocville-npc` marker; the user's own hooks are preserved verbatim.
+ */
+/** Marker used to identify nocville-npc hook commands (flat or nested). */
+export declare const HOOK_MARKER = "nocville-npc";
+/**
+ * Trailing shell comment appended to hook commands. `/bin/sh` ignores it, but it
+ * guarantees the marker is present for idempotency regardless of install path.
+ */
+export declare const HOOK_MARKER_COMMENT = "# nocville-npc-hook";
+export interface CommandHook {
+    type: string;
+    command: string;
+    timeout?: number;
+    [key: string]: unknown;
+}
+export interface HookGroup {
+    matcher?: string;
+    hooks: CommandHook[];
+    [key: string]: unknown;
+}
+export interface HooksFile {
+    hooks?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Install one nocville hook group into each of `events`. Idempotent: existing
+ * nocville entries (flat legacy or nested) are removed first, preserving the
+ * user's own hooks, then a single group per event is appended. Mutates `file`.
+ */
+export declare function installHookGroups(file: HooksFile, command: string, events: readonly string[], extra?: {
+    timeout?: number;
+    perEvent?: Record<string, Partial<CommandHook>>;
+}): {
+    migrated: number;
+    installed: number;
+};
+/** Remove every nocville hook entry. Mutates `file`; returns the count removed. */
+export declare function removeHookGroups(file: HooksFile): number;
+/** First nocville hook command found in any event (any format). */
+export declare function findNocvilleCommand(file: HooksFile): string | undefined;
+/** Extract a `--flag` value from a command string; supports `=`, quotes, or the space form. */
+export declare function extractFlag(command: string, flag: string): string | undefined;
+/** POSIX single-quote a string so /bin/sh treats it as one literal token. */
+export declare function shellQuote(s: string): string;
+/**
+ * Absolute hook command: `'<node>' '<cli.js>' <agent> hook # nocville-npc-hook`.
+ *
+ * Agents run hooks via `/bin/sh` without the user's interactive PATH (nvm /
+ * homebrew shims are absent), so a bare `nocville-npc` would fail; absolute
+ * paths fix that. No API key on the command line — the hook reads the saved
+ * user config (~/.config/nocville/config.json).
+ */
+export declare function buildAgentHookCommand(cliPath: string, agent: string, extraArgs?: string[], nodePath?: string): string;
+/**
+ * The node binary to bake into hook commands. `process.execPath` is often a
+ * versioned path (e.g. Homebrew's /opt/homebrew/Cellar/node/24.4.1/bin/node)
+ * that disappears on upgrade, so prefer an unversioned PATH entry (e.g.
+ * /opt/homebrew/bin/node) that resolves to the same binary.
+ */
+export declare function stableNodePath(execPath?: string, pathEnv?: string): string;
+/** Realpath the running CLI (follows npm bin symlinks). */
+export declare function resolveCliPath(explicit?: string): string;
+/** Read a JSON hooks/settings file; missing → {}; unparsable → null (refuse to overwrite). */
+export declare function readJsonFile(path: string): HooksFile | null;
+/** Write JSON, keeping a one-time `.nocville-backup` of the original file. */
+export declare function writeJsonFile(path: string, data: HooksFile): void;
+export declare function buildShimHookCommand(agent: string, platform?: NodeJS.Platform): string;
+//# sourceMappingURL=hook-settings.d.ts.map