@kylecheng3146/agent-ops 0.1.5 → 0.1.6

package/dist/runtime/src/adapters/claude/config.js

@@ -1,4 +1,17 @@
 import { AgentOpsError } from "../../fs/paths.js";
+const CLAUDE_LOOP_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop"
+];
+const CLAUDE_HOOK_MARKER = "--managed-by=agent-ops";
+const CLAUDE_LOOP_LAUNCHER = "${CLAUDE_PROJECT_DIR}/.claude/hooks/agent-ops-loop.sh";
 export function claudeSettingsTarget(scope) {
     return scope === "project"
         ? {
@@ -18,7 +31,7 @@ function commandHook(event, runtimePath) {
             runtimePath,
             "claude",
             event,
-            "--managed-by=agent-ops"
+            CLAUDE_HOOK_MARKER
         ],
         timeout: 30
     };
@@ -29,6 +42,25 @@ function matcherGroup(event, runtimePath) {
         hooks: [commandHook(event, runtimePath)]
     };
 }
+function loopMatcherGroup(event) {
+    return {
+        ...(event === "PreToolUse" || event === "PermissionRequest"
+            ? { matcher: "Bash" }
+            : {}),
+        hooks: [
+            {
+                type: "command",
+                command: "bash",
+                args: [
+                    CLAUDE_LOOP_LAUNCHER,
+                    event,
+                    CLAUDE_HOOK_MARKER
+                ],
+                timeout: 30
+            }
+        ]
+    };
+}
 export function buildClaudeHookSettings(capabilities, runtimePath) {
     if (runtimePath.length === 0 ||
         runtimePath.length > 4096 ||
@@ -36,11 +68,18 @@ export function buildClaudeHookSettings(capabilities, runtimePath) {
         throw new AgentOpsError("CLAUDE_HOOK_PATH_INVALID", "Claude hook runtime path is invalid.");
     }
     const hooks = {};
-    if (capabilities.includes("lifecycle-summary")) {
-        hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
+    if (capabilities.includes("project-loop")) {
+        for (const event of CLAUDE_LOOP_EVENTS) {
+            hooks[event] = [loopMatcherGroup(event)];
+        }
     }
-    if (capabilities.includes("command-policy")) {
-        hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
+    else {
+        if (capabilities.includes("lifecycle-summary")) {
+            hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
+        }
+        if (capabilities.includes("command-policy")) {
+            hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
+        }
     }
     if (capabilities.includes("optional-stop-verify")) {
         hooks.Stop = [matcherGroup("Stop", runtimePath)];
@@ -50,19 +89,26 @@ export function buildClaudeHookSettings(capabilities, runtimePath) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isOwnedHandler(handler) {
-    if (!isRecord(handler) ||
-        handler.command !== "node" ||
-        !Array.isArray(handler.args)) {
+/**
+ * Matches only the two command shapes agent-ops actually generates. This is
+ * reused by installation inspection so a foreign hook cannot masquerade as
+ * ours merely by carrying the marker string.
+ */
+export function isClaudeManagedHandler(handler) {
+    if (!isRecord(handler) || !Array.isArray(handler.args)) {
         return false;
     }
-    return handler.args[3] === "--managed-by=agent-ops";
+    return ((handler.command === "node" &&
+        handler.args[3] === CLAUDE_HOOK_MARKER) ||
+        (handler.command === "bash" &&
+            handler.args[0] === CLAUDE_LOOP_LAUNCHER &&
+            handler.args[2] === CLAUDE_HOOK_MARKER));
 }
 function withoutOwnedHandlers(value) {
     if (!isRecord(value) || !Array.isArray(value.hooks)) {
         return value;
     }
-    const hooks = value.hooks.filter((handler) => !isOwnedHandler(handler));
+    const hooks = value.hooks.filter((handler) => !isClaudeManagedHandler(handler));
     return hooks.length === 0 ? null : { ...value, hooks };
 }
 function hookRecord(settings) {

package/dist/runtime/src/adapters/claude/events.js

@@ -1,6 +1,13 @@
 export const CLAUDE_SUPPORTED_EVENTS = [
     "SessionStart",
+    "UserPromptSubmit",
     "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop",
     "Stop"
 ];
 export function claudeNonInteractiveTrust(printMode) {

package/dist/runtime/src/adapters/claude/output.js

@@ -6,6 +6,7 @@ function json(value) {
     };
 }
 export function claudeHookOutput(event, result) {
+    const denialReason = result.remedy === undefined ? result.code : `${result.code}: ${result.remedy}`;
     if (event === "Stop" && result.evidence !== undefined) {
         return json({
             systemMessage: `agent-ops: ${result.code}`,
@@ -20,7 +21,7 @@ export function claudeHookOutput(event, result) {
             hookSpecificOutput: {
                 hookEventName: "PreToolUse",
                 permissionDecision: "deny",
-                permissionDecisionReason: result.code
+                permissionDecisionReason: denialReason
             }
         });
     }

package/dist/runtime/src/adapters/codex/config.js

@@ -1,5 +1,16 @@
 import { AgentOpsError } from "../../fs/paths.js";
 export const CODEX_MANAGED_MARKER = "--managed-by=agent-ops";
+const CODEX_LOOP_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop"
+];
 /**
  * Releases up to 0.1.4 registered a bare `agent-ops` command resolved through
  * PATH. Detection still recognizes it so an update replaces it instead of
@@ -35,6 +46,23 @@ function matcherGroup(event, runtimePath) {
         hooks: [commandHook(event, runtimePath)]
     };
 }
+function loopMatcherGroup(event) {
+    const command = `bash "$(git rev-parse --show-toplevel)/.codex/hooks/agent-ops-loop.sh" ${event} ${CODEX_MANAGED_MARKER}`;
+    return {
+        ...(event === "PreToolUse" || event === "PermissionRequest"
+            ? { matcher: "^Bash$" }
+            : {}),
+        hooks: [
+            {
+                type: "command",
+                command,
+                commandWindows: command,
+                timeout: 30,
+                statusMessage: `Running agent-ops ${event}`
+            }
+        ]
+    };
+}
 export function codexHookTarget(scope) {
     return {
         path: ".codex/hooks.json",
@@ -45,11 +73,18 @@ export function codexHookTarget(scope) {
 export function buildCodexHookConfig(capabilities, runtimePath) {
     assertRuntimePath(runtimePath);
     const hooks = {};
-    if (capabilities.includes("lifecycle-summary")) {
-        hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
+    if (capabilities.includes("project-loop")) {
+        for (const event of CODEX_LOOP_EVENTS) {
+            hooks[event] = [loopMatcherGroup(event)];
+        }
     }
-    if (capabilities.includes("command-policy")) {
-        hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
+    else {
+        if (capabilities.includes("lifecycle-summary")) {
+            hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
+        }
+        if (capabilities.includes("command-policy")) {
+            hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
+        }
     }
     if (capabilities.includes("optional-stop-verify")) {
         hooks.Stop = [matcherGroup("Stop", runtimePath)];

package/dist/runtime/src/adapters/codex/events.js

@@ -1,6 +1,13 @@
 export const CODEX_SUPPORTED_EVENTS = [
     "SessionStart",
+    "UserPromptSubmit",
     "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop",
     "Stop"
 ];
 export function codexMatcherSupport(event) {

package/dist/runtime/src/fs/managed-block.js

@@ -7,37 +7,54 @@ function assertBlockId(id) {
         throw new AgentOpsError("INVALID_BLOCK_ID", `Invalid block ID: ${id}`);
     }
 }
-function assertExactMarkerSyntax(source) {
-    const validMarker = /^<!-- agent-ops:(?:start [a-z][a-z0-9-]{0,127} v[1-9][0-9]*|end [a-z][a-z0-9-]{0,127}) -->$/;
+function assertExactMarkerSyntax(source, markerStyle) {
+    const validMarker = markerStyle === "html"
+        ? /^<!-- agent-ops:(?:start [a-z][a-z0-9-]{0,127} v[1-9][0-9]*|end [a-z][a-z0-9-]{0,127}) -->$/
+        : /^# agent-ops:(?:start [a-z][a-z0-9-]{0,127} v[1-9][0-9]*|end [a-z][a-z0-9-]{0,127})$/;
+    const markerPrefix = markerStyle === "html"
+        ? /<!--\s*agent-ops:/
+        : /#\s*agent-ops:/;
     for (const line of source.split(/\r?\n/)) {
-        if (/<!--\s*agent-ops:/.test(line) && !validMarker.test(line)) {
+        if (markerPrefix.test(line) && !validMarker.test(line)) {
             throw new AgentOpsError("MALFORMED_MANAGED_BLOCK", "Managed block markers must use the exact agent-ops marker syntax.");
         }
     }
 }
-export function managedBlockMarkers(id, version) {
+export function managedBlockMarkers(id, version, markerStyle = "html") {
     assertBlockId(id);
     if (!Number.isSafeInteger(version) || version < 1) {
         throw new AgentOpsError("INVALID_BLOCK_VERSION", `Invalid block version: ${version}`);
     }
-    return {
-        start: `<!-- agent-ops:start ${id} v${version} -->`,
-        end: `<!-- agent-ops:end ${id} -->`
-    };
+    return markerStyle === "html"
+        ? {
+            start: `<!-- agent-ops:start ${id} v${version} -->`,
+            end: `<!-- agent-ops:end ${id} -->`
+        }
+        : {
+            start: `# agent-ops:start ${id} v${version}`,
+            end: `# agent-ops:end ${id}`
+        };
 }
-function locateMarkers(source, id, version) {
+function locateMarkers(source, id, version, markerStyle = "html") {
     assertBlockId(id);
-    assertExactMarkerSyntax(source);
+    assertExactMarkerSyntax(source, markerStyle);
     const escapedId = escapeRegExp(id);
+    const startPattern = markerStyle === "html"
+        ? `<!-- agent-ops:start ${escapedId} v[0-9]+ -->`
+        : `# agent-ops:start ${escapedId} v[0-9]+`;
+    const end = markerStyle === "html"
+        ? `<!-- agent-ops:end ${id} -->`
+        : `# agent-ops:end ${id}`;
     const startMatches = [
-        ...source.matchAll(new RegExp(`<!-- agent-ops:start ${escapedId} v[0-9]+ -->`, "g"))
+        ...source.matchAll(new RegExp(startPattern, "g"))
     ];
-    const end = `<!-- agent-ops:end ${id} -->`;
     const endMatches = [...source.matchAll(new RegExp(escapeRegExp(end), "g"))];
     if (startMatches.length === 0 && endMatches.length === 0) {
         return null;
     }
-    const expectedStart = version === undefined ? startMatches[0]?.[0] : managedBlockMarkers(id, version).start;
+    const expectedStart = version === undefined
+        ? startMatches[0]?.[0]
+        : managedBlockMarkers(id, version, markerStyle).start;
     const start = startMatches[0]?.[0];
     const startIndex = startMatches[0]?.index;
     const endIndex = endMatches[0]?.index;
@@ -54,16 +71,16 @@ function locateMarkers(source, id, version) {
     return { start, end, startIndex, endIndex };
 }
 function renderBlock(options) {
-    if (/<!--\s*agent-ops:/.test(options.content)) {
+    if (/(?:<!--|#)\s*agent-ops:/.test(options.content)) {
         throw new AgentOpsError("AMBIGUOUS_MANAGED_CONTENT", "Managed content must not contain agent-ops marker boundaries.");
     }
-    const { start, end } = managedBlockMarkers(options.id, options.version);
+    const { start, end } = managedBlockMarkers(options.id, options.version, options.markerStyle);
     const content = options.content.replace(/\r\n/g, "\n").replace(/\n+$/g, "");
     return `${start}\n${content}\n${end}`;
 }
 export function applyManagedBlock(source, options) {
     const block = renderBlock(options);
-    const located = locateMarkers(source, options.id, options.version);
+    const located = locateMarkers(source, options.id, options.version, options.markerStyle);
     if (located === null) {
         if (source.length === 0) {
             return `${block}\n`;
@@ -72,8 +89,8 @@ export function applyManagedBlock(source, options) {
     }
     return `${source.slice(0, located.startIndex)}${block}${source.slice(located.endIndex + located.end.length)}`;
 }
-export function removeManagedBlock(source, id) {
-    const located = locateMarkers(source, id);
+export function removeManagedBlock(source, id, markerStyle = "html") {
+    const located = locateMarkers(source, id, undefined, markerStyle);
     if (located === null) {
         return source;
     }