@pugi/cli 0.1.0-alpha.3 → 0.1.0-alpha.5

package/dist/core/engine/prompts.js

@@ -1,3 +1,4 @@
+import { getJobRegistry, summarizeJobsForPrompt, } from '../jobs/registry.js';
 /**
  * System prompts for each engine command. Each prompt:
  *   - Anchors the model in Pugi's local-first contract (ADR-0037).
@@ -11,6 +12,12 @@
  * the persona system prompt comes from the runtime (Anvil bridge
  * prepends `oes-dev` / Sigma prompt automatically when configured); these
  * prompts ride on top and scope the model to the current command.
+ *
+ * Sprint α5.9 (ADR-0056 PR-PUGI-CLI-M1-GAP-J): the system prompt picks up
+ * a `BACKGROUND JOBS:` snapshot appended at the tail so the agent loop
+ * knows what background bash work is currently on watch and can avoid
+ * spawning a duplicate. The snapshot is sourced from `JobRegistry` and
+ * formatted by `summarizeJobsForPrompt` so the surface is single-sourced.
  */
 const COMMON_LOCAL_FIRST_PREAMBLE = [
     'You are the Pugi CLI agent running locally inside the operator\'s repository.',
@@ -26,6 +33,13 @@ const EDIT_FLOW_RULES = [
     'After your last tool call, summarise what you changed and what the operator should review.',
 ].join(' ');
 export function systemPromptFor(kind) {
+    const base = baseSystemPromptFor(kind);
+    const snapshot = formatBackgroundJobsSnapshot(getJobRegistrySafely());
+    if (!snapshot)
+        return base;
+    return `${base}\n\n${snapshot}`;
+}
+function baseSystemPromptFor(kind) {
     switch (kind) {
         case 'code':
             return [
@@ -64,6 +78,34 @@ export function systemPromptFor(kind) {
             ].join('\n\n');
     }
 }
+/**
+ * Builds the BACKGROUND JOBS snapshot block injected at the tail of
+ * the system prompt. Sync because the surrounding `systemPromptFor`
+ * builder is sync (the engine adapter does not await prompt
+ * assembly) and the JobRegistry's `listSync()` is essentially free
+ * (single JSON file read with sync fs primitives). Returns an empty
+ * string if the registry cannot be reached so the prompt assembly
+ * never crashes when the ledger is unavailable.
+ */
+export function formatBackgroundJobsSnapshot(registry) {
+    if (!registry)
+        return '';
+    try {
+        const entries = registry.listSync();
+        return summarizeJobsForPrompt(entries);
+    }
+    catch {
+        return '';
+    }
+}
+function getJobRegistrySafely() {
+    try {
+        return getJobRegistry();
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Anvil persona slug to invoke per command. Today every command routes
  * to `oes-dev` (Sigma) — the Tier-2 reviewer persona already configured

package/dist/core/engine/tool-bridge.js

@@ -1,4 +1,5 @@
-import { bashTool, editTool, globTool, grepTool, readTool, writeTool, } from '../../tools/file-tools.js';
+import { editTool, globTool, grepTool, readTool, writeTool, } from '../../tools/file-tools.js';
+import { bashToolSync } from '../../tools/bash.js';
 /**
  * Tool-bridge: turns the abstract tool registry into:
  *   1. An OpenAI-shaped tools schema for `EngineLoopClient.send`.
@@ -134,7 +135,7 @@ function requireString(obj, key) {
     return v;
 }
 export function buildExecutor(input) {
-    const { kind, ctx } = input;
+    const { kind, ctx, hooks, sessionId } = input;
     const planMode = kind === 'plan';
     return async ({ name, arguments: argsRaw }) => {
         if (!WIRED_TOOLS.has(name)) {
@@ -146,70 +147,167 @@ export function buildExecutor(input) {
             // outcome, not a failure, because plan mode is doing its job.
             throw new Error(`PLAN_MODE_REFUSED: ${name} is not allowed in plan mode`);
         }
-        const args = parseArgs(argsRaw);
-        switch (name) {
-            case 'read': {
-                const { path } = { path: requireString(args, 'path') };
-                const content = readTool(ctx, path);
-                // Cap the content surfaced back to the model so a 10MB file
-                // does not blow the context window. The model sees the head
-                // and a truncation marker; if it needs more it can grep.
-                const CAP = 32 * 1024;
-                if (content.length > CAP) {
-                    return `${content.slice(0, CAP)}\n(...truncated at ${CAP} bytes; use grep or glob to narrow the read)`;
+        // Fire PreToolUse hooks. The match grammar takes the tool name and
+        // (when extractable) the target path. Each new tool dispatch starts a
+        // fresh dedup batch so a hook fires once per dispatch, not once per
+        // session.
+        if (hooks && sessionId) {
+            hooks.resetBatch();
+            const path = extractToolPath(name, argsRaw);
+            const preCtx = {
+                sessionId,
+                event: 'PreToolUse',
+                tool: name,
+                path,
+                payload: { tool: name, arguments: argsRaw },
+            };
+            // List the matching hooks BEFORE firing so we can correlate
+            // hook[i] with result[i] when checking onFailure: 'block'. The
+            // ordering of listMatching and fire is stable: fire iterates the
+            // same listMatching output internally.
+            const matchingPreHooks = hooks.listMatching(preCtx);
+            const preResults = await hooks.fire(preCtx);
+            for (let i = 0; i < matchingPreHooks.length; i += 1) {
+                const hook = matchingPreHooks[i];
+                const result = preResults[i];
+                if (hook && result && hook.onFailure === 'block' && !result.ok) {
+                    throw new Error(`HOOK_BLOCKED: PreToolUse hook (${hook.run.slice(0, 80)}) refused ${name} (exit=${result.exitCode})`);
                 }
-                return content;
-            }
-            case 'write': {
-                const wargs = {
-                    path: requireString(args, 'path'),
-                    content: requireString(args, 'content'),
-                };
-                writeTool(ctx, wargs.path, wargs.content);
-                return `wrote ${wargs.path} (${wargs.content.length} bytes)`;
-            }
-            case 'edit': {
-                const eargs = {
-                    path: requireString(args, 'path'),
-                    oldString: requireString(args, 'oldString'),
-                    newString: requireString(args, 'newString'),
-                };
-                editTool(ctx, eargs.path, eargs.oldString, eargs.newString);
-                return `edited ${eargs.path}`;
             }
-            case 'grep': {
-                const gargs = { query: requireString(args, 'query') };
-                const matches = grepTool(ctx, gargs.query);
-                if (matches.length === 0)
-                    return `no matches for ${gargs.query}`;
-                const head = matches.slice(0, 50);
-                const rendered = head.map((m) => `${m.path}:${m.line}: ${m.text}`).join('\n');
-                const more = matches.length > head.length ? `\n(... ${matches.length - head.length} more)` : '';
-                return `${matches.length} match(es):\n${rendered}${more}`;
-            }
-            case 'glob': {
-                const gargs = { pattern: requireString(args, 'pattern') };
-                const results = globTool(ctx, gargs.pattern);
-                if (results.length === 0)
-                    return `no paths match ${gargs.pattern}`;
-                return `${results.length} path(s):\n${results.slice(0, 100).join('\n')}${results.length > 100 ? `\n(... ${results.length - 100} more)` : ''}`;
+        }
+        const args = parseArgs(argsRaw);
+        const dispatch = async () => {
+            return dispatchTool(name, args, ctx);
+        };
+        try {
+            const result = await dispatch();
+            if (hooks && sessionId) {
+                const path = extractToolPath(name, argsRaw);
+                await hooks.fire({
+                    sessionId,
+                    event: 'PostToolUse',
+                    tool: name,
+                    path,
+                    payload: { tool: name, arguments: argsRaw, ok: true, result: result.slice(0, 1024) },
+                });
             }
-            case 'bash': {
-                const bargs = { command: requireString(args, 'command') };
-                const result = bashTool(ctx, bargs.command);
-                const body = [
-                    `exit=${result.exitCode}`,
-                    result.stdout ? `stdout:\n${result.stdout}` : '',
-                    result.stderr ? `stderr:\n${result.stderr}` : '',
-                ]
-                    .filter(Boolean)
-                    .join('\n');
-                return body || '(no output)';
+            return result;
+        }
+        catch (error) {
+            if (hooks && sessionId) {
+                const path = extractToolPath(name, argsRaw);
+                await hooks.fire({
+                    sessionId,
+                    event: 'PostToolUseFailure',
+                    tool: name,
+                    path,
+                    payload: {
+                        tool: name,
+                        arguments: argsRaw,
+                        ok: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    },
+                });
             }
-            default:
-                // Exhaustive; unreachable because of the WIRED_TOOLS guard above.
-                throw new Error(`unhandled tool: ${name}`);
+            throw error;
         }
     };
 }
+/**
+ * Best-effort extraction of the file path a tool targets. Returns
+ * undefined when the tool does not take a path or the path cannot be
+ * parsed cleanly — match rules with a `pathGlob` will then skip this
+ * dispatch, which is the safe default.
+ */
+function extractToolPath(name, argsRaw) {
+    if (name !== 'read' && name !== 'write' && name !== 'edit')
+        return undefined;
+    try {
+        const parsed = JSON.parse(argsRaw);
+        const path = parsed.path;
+        return typeof path === 'string' ? path : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function dispatchTool(name, args, ctx) {
+    switch (name) {
+        case 'read': {
+            const { path } = { path: requireString(args, 'path') };
+            const content = readTool(ctx, path);
+            // Cap the content surfaced back to the model so a 10MB file
+            // does not blow the context window. The model sees the head
+            // and a truncation marker; if it needs more it can grep.
+            const CAP = 32 * 1024;
+            if (content.length > CAP) {
+                return `${content.slice(0, CAP)}\n(...truncated at ${CAP} bytes; use grep or glob to narrow the read)`;
+            }
+            return content;
+        }
+        case 'write': {
+            const wargs = {
+                path: requireString(args, 'path'),
+                content: requireString(args, 'content'),
+            };
+            writeTool(ctx, wargs.path, wargs.content);
+            return `wrote ${wargs.path} (${wargs.content.length} bytes)`;
+        }
+        case 'edit': {
+            const eargs = {
+                path: requireString(args, 'path'),
+                oldString: requireString(args, 'oldString'),
+                newString: requireString(args, 'newString'),
+            };
+            editTool(ctx, eargs.path, eargs.oldString, eargs.newString);
+            return `edited ${eargs.path}`;
+        }
+        case 'grep': {
+            const gargs = { query: requireString(args, 'query') };
+            const matches = grepTool(ctx, gargs.query);
+            if (matches.length === 0)
+                return `no matches for ${gargs.query}`;
+            const head = matches.slice(0, 50);
+            const rendered = head.map((m) => `${m.path}:${m.line}: ${m.text}`).join('\n');
+            const more = matches.length > head.length ? `\n(... ${matches.length - head.length} more)` : '';
+            return `${matches.length} match(es):\n${rendered}${more}`;
+        }
+        case 'glob': {
+            const gargs = { pattern: requireString(args, 'pattern') };
+            const results = globTool(ctx, gargs.pattern);
+            if (results.length === 0)
+                return `no paths match ${gargs.pattern}`;
+            return `${results.length} path(s):\n${results.slice(0, 100).join('\n')}${results.length > 100 ? `\n(... ${results.length - 100} more)` : ''}`;
+        }
+        case 'bash': {
+            const bargs = { command: requireString(args, 'command') };
+            // The class-aware bash tool (sprint α5.2) replaces the legacy
+            // file-tools entry point. We use the sync variant here because
+            // dispatchTool's signature is sync; the async tool is reserved
+            // for the REPL path (sprint α5.7) where promises are first class.
+            const result = bashToolSync({ cmd: bargs.command }, {
+                root: ctx.root,
+                settings: ctx.settings,
+                session: ctx.session,
+                source: 'agent',
+            });
+            const parts = [
+                `exit=${result.exitCode}`,
+                result.stdout ? `stdout:\n${result.stdout}` : '',
+                result.stderr ? `stderr:\n${result.stderr}` : '',
+            ];
+            if (result.artifactRef)
+                parts.push(`artifactRef=${result.artifactRef}`);
+            if (result.truncated)
+                parts.push('truncated=true');
+            if (result.timedOut)
+                parts.push('timedOut=true');
+            const body = parts.filter(Boolean).join('\n');
+            return body || '(no output)';
+        }
+        default:
+            // Exhaustive; unreachable because of the WIRED_TOOLS guard above.
+            throw new Error(`unhandled tool: ${name}`);
+    }
+}
 //# sourceMappingURL=tool-bridge.js.map