greprag 5.78.1 → 5.78.6

package/dist/commands/coordinate-gate.js

@@ -1,232 +0,0 @@
-"use strict";
-/** Coordinate-GATE — the high-value half of the cross-session coordination reflex.
- *  Fires at the moment of a risky SHARED-STATE action (git merge / push / deploy)
- *  and, if another live session is working in THIS repo, compels the agent to
- *  coordinate with that peer BEFORE the irreversible action runs. Automates the
- *  manual "notice the peer, message them, then merge" handshake.
- *
- *  SEAM (forward-compat — agreed with ec71d875/36ef8cb8): the EVAL+message
- *  (runCoordinateGate) is decoupled from the trigger SOURCE. The PreToolUse
- *  adapter (triggerFromPreToolUse) is the only piece that knows the tool-call
- *  shape; it produces a source-agnostic CoordinateTrigger. The eval does a FRESH
- *  watcher read and builds the directive without ever seeing the source. The
- *  ddb7dcc8 ingress-trigger bridge will add a SECOND source (message-ingress /
- *  stress-threshold / registry-change) that produces its own CoordinateTrigger
- *  and calls this same eval — purely additive, no refactor of the gate.
- *
- *  WHY NOT A guard.ts MATCHSET RULE: the matchset dispatcher is local-only/pure
- *  (no network on the hot path — the D5 "ad-blocker" model) and injects STATIC
- *  rule text. This gate needs a FRESH `inbox watchers` network read at fire time
- *  (a stale roster at merge is the exact failure it prevents), which a static
- *  matchset cannot express. So it is a hand-wired PreToolUse hook like
- *  collision-check — the documented fallback in the chip spec. The bridge's
- *  shared eval will likewise need this off-hot-path read, so this module is its
- *  home too. docs/collision-schematic.md, docs/harness-control-point-matrix.md
- *
- *  NO DEDUP: every fire does a fresh read. Unlike the SessionStart roster (which
- *  dedups to stay quiet), the merge gate must reflect live truth each time.
- *
- *  EFFECT is the adapter's choice, not the eval's: Claude/OpenCode inject the
- *  fresh roster as context. Codex keeps delivery coordination in the native
- *  agent/tool layer through the Delivery announce, because shell hooks cannot
- *  observe native task coordination. An ingress-source wrapper would inject
- *  instead. The eval below only produces the message.
- *
- *  Shared-file Write was CONSIDERED (chip spec) but deferred: classifying a
- *  write as "shared" is ambiguous, and a fresh network read on every Write/Edit
- *  is too costly/noisy for the value — merge/push/deploy is where irreversible
- *  shared-state mutation actually happens. The eval is ready for a future Write
- *  adapter; only a new triggerFrom* + a `Write|Edit` matcher would be needed. */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasGitSubcommand = hasGitSubcommand;
-exports.classifyRiskyCommand = classifyRiskyCommand;
-exports.triggerFromPreToolUse = triggerFromPreToolUse;
-exports.buildCoordinateDirective = buildCoordinateDirective;
-exports.resolveCollisionPeers = resolveCollisionPeers;
-exports.runCoordinateGate = runCoordinateGate;
-const collision_check_1 = require("./collision-check");
-/** Risky shared-state command signatures. Each segment of a (possibly chained)
- *  Bash command is tested against these. SPECIFIC to the Bash/PreToolUse source. */
-const RISKY_PATTERNS = [
-    { kind: 'merge', label: 'gh pr merge', re: /^gh\s+pr\s+merge\b/ },
-    { kind: 'deploy', label: 'wrangler deploy', re: /^(?:npx\s+)?wrangler\s+deploy\b/ },
-    { kind: 'deploy', label: 'npm run deploy', re: /^npm\s+run\s+deploy\b/ },
-    { kind: 'deploy', label: 'npm publish', re: /^npm\s+publish\b/ },
-    { kind: 'deploy', label: 'gh release create', re: /^gh\s+release\s+create\b/ },
-];
-/** Split a shell command on executable separators so `cd x && git push` is
- * caught, while regex/search patterns like `"before; git push; after"` stay a
- * single argument. */
-function commandSegments(command) {
-    const segments = [];
-    let current = '';
-    let quote = null;
-    let escaped = false;
-    const flush = () => {
-        const trimmed = current.trim();
-        if (trimmed)
-            segments.push(trimmed);
-        current = '';
-    };
-    for (let i = 0; i < command.length; i++) {
-        const ch = command[i];
-        const next = command[i + 1];
-        if (escaped) {
-            current += ch;
-            escaped = false;
-            continue;
-        }
-        if (ch === '\\' && quote !== "'") {
-            current += ch;
-            escaped = true;
-            continue;
-        }
-        if (quote) {
-            current += ch;
-            if (ch === quote)
-                quote = null;
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            quote = ch;
-            current += ch;
-            continue;
-        }
-        if (ch === '\n' || ch === ';' || ch === '|') {
-            flush();
-            if ((ch === '|' && next === '|'))
-                i++;
-            continue;
-        }
-        if (ch === '&' && next === '&') {
-            flush();
-            i++;
-            continue;
-        }
-        current += ch;
-    }
-    flush();
-    return segments;
-}
-/** Parse enough shell words to locate a git subcommand after global options.
- * Codex worktrees routinely use `git -C <main> merge ...`; matching only
- * `^git merge` left the most common Codex landing shape outside the gate. */
-function shellWords(segment) {
-    const matches = segment.match(/"(?:\\.|[^"])*"|'[^']*'|[^\s]+/g) || [];
-    return matches.map(word => {
-        if ((word.startsWith('"') && word.endsWith('"'))
-            || (word.startsWith("'") && word.endsWith("'"))) {
-            return word.slice(1, -1);
-        }
-        return word;
-    });
-}
-function classifyGit(tokens) {
-    if (tokens[0] !== 'git')
-        return null;
-    let i = 1;
-    const optionsWithValue = new Set([
-        '-C', '-c', '--exec-path', '--git-dir', '--work-tree', '--namespace', '--super-prefix', '--config-env',
-    ]);
-    while (i < tokens.length && tokens[i].startsWith('-')) {
-        const option = tokens[i++];
-        if (optionsWithValue.has(option) && i < tokens.length)
-            i++;
-    }
-    const subcommand = tokens[i];
-    if (subcommand === 'merge')
-        return { kind: 'merge', label: 'git merge' };
-    if (subcommand === 'rebase')
-        return { kind: 'merge', label: 'git rebase' };
-    if (subcommand === 'push')
-        return { kind: 'push', label: 'git push' };
-    return null;
-}
-/** True when any executable command segment invokes the requested Git
- * subcommand, including `git -C <worktree> <subcommand>`. Exported so lifecycle
- * hooks can key off agent-generated Git actions instead of user prompt words. */
-function hasGitSubcommand(command, expected) {
-    if (!command || !expected)
-        return false;
-    for (const seg of commandSegments(command)) {
-        const tokens = shellWords(seg);
-        if (tokens[0] !== 'git')
-            continue;
-        let i = 1;
-        const optionsWithValue = new Set([
-            '-C', '-c', '--exec-path', '--git-dir', '--work-tree', '--namespace', '--super-prefix', '--config-env',
-        ]);
-        while (i < tokens.length && tokens[i].startsWith('-')) {
-            const option = tokens[i++];
-            if (optionsWithValue.has(option) && i < tokens.length)
-                i++;
-        }
-        if (tokens[i] === expected)
-            return true;
-    }
-    return false;
-}
-/** Classify a Bash command into a risky-action trigger, or null. PURE. Matches
- *  the FIRST risky segment (a chained command fires on whichever risky verb
- *  appears first). */
-function classifyRiskyCommand(command) {
-    if (!command)
-        return null;
-    for (const seg of commandSegments(command)) {
-        const git = classifyGit(shellWords(seg));
-        if (git)
-            return git;
-        for (const p of RISKY_PATTERNS) {
-            if (p.re.test(seg))
-                return { kind: p.kind, label: p.label };
-        }
-    }
-    return null;
-}
-/** PreToolUse adapter: extract a CoordinateTrigger from a tool call, or null.
- *  SPECIFIC to the PreToolUse event shape — the only source-aware piece. Only
- *  Bash calls carry a risky command; everything else returns null (cheap: the
- *  hook never reaches the network for a non-risky call). */
-function triggerFromPreToolUse(toolName, toolInput) {
-    if (toolName !== 'Bash')
-        return null;
-    const command = typeof toolInput.command === 'string' ? toolInput.command : '';
-    return classifyRiskyCommand(command);
-}
-/** The LOUD coordinate directive — names the action + the live same-repo peers
- *  and tells the agent to message them BEFORE proceeding. PURE, source-agnostic
- *  (takes a CoordinateTrigger, not a PreToolUse event). */
-function buildCoordinateDirective(trigger, peers, myShort, alias) {
-    const handle = alias || '<handle>';
-    const plural = peers.length === 1 ? '' : 's';
-    const list = peers.map(p => p.short).join(', ');
-    return (`COORDINATE before ${trigger.label}: ${peers.length} peer${plural} live in this repo (${list}). `
-        + `Ping before proceeding. Codex peers: use codex_app.list_threads and codex_app.send_message_to_thread. `
-        + `GrepRAG watcher/cross-harness peers: greprag send "heads up, about to ${trigger.label}" `
-        + `--to ${handle}@greprag.com/<8hex> --from-session ${myShort}`);
-}
-/** FRESH watcher read → the same-repo peers live right now (the I/O half, kept out
- *  of the pure module). NO dedup, NO local state: a fresh read every call. Empty on
- *  any failure / no peer (fail-open). The collision Match-on-command module
- *  (collision-reminder.ts) calls this in the hook, then detects purely on the result. */
-async function resolveCollisionPeers(opts) {
-    try {
-        const watchers = await (0, collision_check_1.fetchTenantWatchers)(opts.apiUrl, opts.apiKey);
-        if (watchers.length === 0)
-            return [];
-        return (0, collision_check_1.detectCollisions)(opts.short, opts.projectId, opts.projectName, watchers);
-    }
-    catch {
-        return [];
-    }
-}
-/** Source-agnostic eval+message. Given a trigger from ANY source, resolve live
- *  same-repo peers and return the LOUD directive — or null if none. Retained for
- *  the existing PreToolUse path + tests; the registry now reaches the same result
- *  via resolveCollisionPeers + the collision module. */
-async function runCoordinateGate(trigger, opts) {
-    const peers = await resolveCollisionPeers(opts);
-    if (peers.length === 0)
-        return null;
-    return buildCoordinateDirective(trigger, peers, opts.short, opts.alias);
-}