@nt-ai-lab/deterministic-agent-workflow-cli 0.4.0 → 0.4.2

package/dist/features/workflow-cli/entrypoint/workflow-cli.js

@@ -19,7 +19,7 @@ export function createWorkflowCli(config) {
     const configuredWorkflowEventsDbPath = processDeps.getEnv('WORKFLOW_EVENTS_DB');
     const workflowEventsDbPath = configuredWorkflowEventsDbPath !== undefined && configuredWorkflowEventsDbPath !== ''
         ? configuredWorkflowEventsDbPath
-        : join(readEnvVar('HOME'), '.workflow-events.db');
+        : join(readEnvVar('HOME'), 'ai-workflow-database', '.workflow-events.db');
     const store = processDeps.buildStore(workflowEventsDbPath);
     const now = () => new Date().toISOString();
     const platformCtx = {

package/dist/features/workflow-runner/entrypoint/workflow-runner.js

@@ -149,7 +149,10 @@ function handleRoute(engine, engineDeps, config, args, routeName, readStdin, get
     switch (routeDef.type) {
         case 'session-start': {
             const transcriptPath = getSessionTranscriptPath === undefined ? '' : getSessionTranscriptPath();
-            return engineResultToRunnerResult(engine.startSession(resolveSessionId(), transcriptPath, getSessionRepository?.()));
+            const repository = getSessionRepository === undefined ? '' : getSessionRepository();
+            if (repository === undefined)
+                throw new TypeError('repository must be a non-empty string.');
+            return engineResultToRunnerResult(engine.startSession(resolveSessionId(), transcriptPath, repository));
         }
         case 'transition':
             return engineResultToRunnerResult(engine.transition(resolveSessionId(), config.workflowDefinition.stateSchema.parse(resolveTarget())));
@@ -191,7 +194,10 @@ function handleHook(engine, resolvedHandler, readStdin) {
                 exitCode: EXIT_ALLOW
             };
         }
-        return engineResultToRunnerResult(engine.startSession(common.session_id, common.transcript_path, getRepositoryName(common.cwd)));
+        const repository = getRepositoryName(common.cwd);
+        if (repository === undefined)
+            throw new TypeError('repository must be a non-empty string.');
+        return engineResultToRunnerResult(engine.startSession(common.session_id, common.transcript_path, repository));
     }
     if (!engine.hasSession(common.session_id))
         return {

package/dist/platform/domain/pre-tool-use-handler.d.ts

@@ -1,7 +1,8 @@
 import type { BaseWorkflowState, EngineResult, RehydratableWorkflow, WorkflowEngine } from '@nt-ai-lab/deterministic-agent-workflow-engine';
 import type { BashForbiddenConfig } from '@nt-ai-lab/deterministic-agent-workflow-dsl';
+type PreToolUseEngine<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string, TOperation extends string> = Pick<WorkflowEngine<TWorkflow, TState, TDeps, TStateName, TOperation>, 'transaction' | 'checkBash' | 'checkWrite'>;
 /** @riviere-role value-object */
-export type PreToolUseHandlerFn<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string = string, TOperation extends string = string> = (engine: WorkflowEngine<TWorkflow, TState, TDeps, TStateName, TOperation>, sessionId: string, toolName: string, toolInput: Record<string, unknown>) => EngineResult;
+export type PreToolUseHandlerFn<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string = string, TOperation extends string = string> = (engine: PreToolUseEngine<TWorkflow, TState, TDeps, TStateName, TOperation>, sessionId: string, toolName: string, toolInput: Record<string, unknown>) => EngineResult;
 /** @riviere-role value-object */
 export type CustomPreToolUseGate<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TStateName extends string = string> = {
     readonly name: string;
@@ -19,3 +20,4 @@ export type PreToolUseHandlerConfig<TWorkflow extends RehydratableWorkflow<TStat
 };
 /** @riviere-role domain-service */
 export declare function createPreToolUseHandler<TWorkflow extends RehydratableWorkflow<TState>, TState extends BaseWorkflowState<TStateName>, TDeps, TStateName extends string = string, TOperation extends string = string>(config: PreToolUseHandlerConfig<TWorkflow, TState, TStateName>): PreToolUseHandlerFn<TWorkflow, TState, TDeps, TStateName, TOperation>;
+export {};

package/dist/platform/domain/pre-tool-use-handler.js

@@ -1,12 +1,50 @@
+const BASH_TOOL_NAMES = ['Bash', 'bash'];
+const WRITE_TOOL_NAMES = [
+    // Claude Code
+    'Write', 'Edit', 'MultiEdit', 'NotebookEdit',
+    // OpenCode and Codex
+    'write', 'edit', 'apply_patch',
+];
 /** @riviere-role domain-service */
 export function createPreToolUseHandler(config) {
     return (engine, sessionId, toolName, toolInput) => {
-        const filePath = extractFilePath(toolInput);
         const command = extractCommand(toolInput);
+        const isWriteTool = WRITE_TOOL_NAMES.includes(toolName);
+        const filePaths = isWriteTool ? extractFilePaths(toolName, toolInput) : [extractFilePath(toolInput)];
+        const gateResult = checkCustomGates(config, engine, sessionId, toolName, command, filePaths);
+        if (gateResult !== undefined)
+            return gateResult;
+        if (BASH_TOOL_NAMES.includes(toolName))
+            return engine.checkBash(sessionId, toolName, command, config.bashForbidden);
+        if (!isWriteTool) {
+            return {
+                type: 'success',
+                output: '',
+            };
+        }
+        if (filePaths.length === 0) {
+            return {
+                type: 'blocked',
+                output: `Cannot determine every file edited by ${toolName}.`,
+            };
+        }
+        for (const filePath of filePaths) {
+            const result = engine.checkWrite(sessionId, toolName, filePath, config.isWriteAllowed);
+            if (result.type === 'blocked')
+                return result;
+        }
+        return {
+            type: 'success',
+            output: '',
+        };
+    };
+}
+function checkCustomGates(config, engine, sessionId, toolName, command, filePaths) {
+    for (const filePath of filePaths.length === 0 ? [''] : filePaths) {
         const ctx = {
             toolName,
             filePath,
-            command
+            command,
         };
         for (const gate of config.customGates ?? []) {
             const result = engine.transaction(sessionId, `hook:${gate.name}`, (workflow) => {
@@ -15,25 +53,40 @@ export function createPreToolUseHandler(config) {
                     return { pass: true };
                 return {
                     pass: false,
-                    reason: check
+                    reason: check,
                 };
             });
             if (result.type === 'blocked')
                 return result;
         }
-        const writeCheck = engine.checkWrite(sessionId, toolName, filePath, config.isWriteAllowed);
-        if (writeCheck.type === 'blocked')
-            return writeCheck;
-        return engine.checkBash(sessionId, toolName, command, config.bashForbidden);
-    };
+    }
+    return undefined;
 }
 function extractFilePath(toolInput) {
     return resolveStringField(toolInput['file_path'])
+        || resolveStringField(toolInput['filePath'])
+        || resolveStringField(toolInput['notebook_path'])
         || resolveStringField(toolInput['path'])
         || resolveStringField(toolInput['pattern']);
 }
+function extractFilePaths(toolName, toolInput) {
+    const filePath = extractFilePath(toolInput);
+    if (filePath.length > 0)
+        return [filePath];
+    if (toolName !== 'apply_patch')
+        return [];
+    const patchText = resolveStringField(toolInput['patchText']) || resolveStringField(toolInput['command']);
+    const paths = new Set();
+    for (const line of patchText.split('\n')) {
+        const match = /^\*\*\* (?:Update|Add|Delete) File: (.+)$|^\*\*\* Move to: (.+)$/.exec(line);
+        const path = match?.[1] ?? match?.[2];
+        if (path !== undefined && path.trim().length > 0)
+            paths.add(path.trim());
+    }
+    return [...paths];
+}
 function extractCommand(toolInput) {
-    return resolveStringField(toolInput['command']);
+    return resolveStringField(toolInput['command']) || resolveStringField(toolInput['patchText']);
 }
 function resolveStringField(value) {
     if (value === undefined || value === null)

package/dist/platform/domain/pre-tool-use-handler.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/platform/domain/pre-tool-use-handler.spec.js

@@ -0,0 +1,80 @@
+import { describe, expect, it, vi, } from 'vitest';
+import { createPreToolUseHandler } from './pre-tool-use-handler.js';
+const success = {
+    type: 'success',
+    output: '',
+};
+function createEngine() {
+    const checkBash = vi.fn((...args) => {
+        void args;
+        return success;
+    });
+    const checkWrite = vi.fn((...args) => {
+        void args;
+        return success;
+    });
+    return {
+        engine: {
+            transaction: vi.fn(() => success),
+            checkBash,
+            checkWrite,
+        },
+        checkBash,
+        checkWrite,
+    };
+}
+function createHandler() {
+    return createPreToolUseHandler({
+        bashForbidden: { commands: [] },
+        isWriteAllowed: () => true,
+    });
+}
+describe('createPreToolUseHandler', () => {
+    it.each([
+        ['Write', { file_path: 'src/file.ts' }],
+        ['Edit', { file_path: 'src/file.ts' }],
+        ['MultiEdit', { file_path: 'src/file.ts' }],
+        ['NotebookEdit', { notebook_path: 'src/notebook.ipynb' }],
+    ])('checks the Claude Code %s tool as a write', (toolName, toolInput) => {
+        const { engine, checkWrite, } = createEngine();
+        createHandler()(engine, 'session-1', toolName, toolInput);
+        expect(checkWrite).toHaveBeenCalledOnce();
+        expect(checkWrite).toHaveBeenCalledWith('session-1', toolName, toolName === 'NotebookEdit' ? 'src/notebook.ipynb' : 'src/file.ts', expect.any(Function));
+    });
+    it('checks OpenCode writes and every path in an apply_patch input', () => {
+        const { engine, checkWrite, } = createEngine();
+        const handler = createHandler();
+        handler(engine, 'session-1', 'write', { filePath: 'src/file.ts' });
+        handler(engine, 'session-1', 'edit', { filePath: 'src/file.ts' });
+        handler(engine, 'session-1', 'apply_patch', { patchText: '*** Begin Patch\n*** Update File: src/old.ts\n*** Move to: src/new.ts\n*** End Patch' });
+        expect(checkWrite.mock.calls.map(([, toolName, filePath]) => [toolName, filePath])).toStrictEqual([
+            ['write', 'src/file.ts'],
+            ['edit', 'src/file.ts'],
+            ['apply_patch', 'src/old.ts'],
+            ['apply_patch', 'src/new.ts'],
+        ]);
+    });
+    it('checks Claude Code and OpenCode Bash tools through Bash policy', () => {
+        const { engine, checkBash, checkWrite, } = createEngine();
+        const handler = createHandler();
+        handler(engine, 'session-1', 'Bash', { command: 'pwd' });
+        handler(engine, 'session-1', 'bash', { command: 'pwd' });
+        expect(checkBash).toHaveBeenCalledTimes(2);
+        expect(checkWrite).not.toHaveBeenCalled();
+    });
+    it('allows non-write tools without calling write policy', () => {
+        const { engine, checkWrite, } = createEngine();
+        const result = createHandler()(engine, 'session-1', 'workflow', { operation: 'record-issue' });
+        expect(result).toStrictEqual(success);
+        expect(checkWrite).not.toHaveBeenCalled();
+    });
+    it('blocks an apply_patch tool when no edited paths can be determined', () => {
+        const { engine, checkWrite, } = createEngine();
+        const result = createHandler()(engine, 'session-1', 'apply_patch', { patchText: 'not a patch' });
+        expect(result).toStrictEqual({
+            type: 'blocked',
+            output: 'Cannot determine every file edited by apply_patch.',
+        });
+        expect(checkWrite).not.toHaveBeenCalled();
+    });
+});

package/dist/platform/infra/external-clients/claude-hooks/hook-schemas.js

@@ -1,19 +1,19 @@
 import { z } from 'zod';
 const hookCommonInputSchema = z.object({
-    session_id: z.string(),
-    transcript_path: z.string(),
-    cwd: z.string(),
+    session_id: z.string().trim().min(1),
+    transcript_path: z.string().trim().min(1),
+    cwd: z.string().trim().min(1),
     permission_mode: z.string().optional(),
-    hook_event_name: z.string(),
+    hook_event_name: z.string().trim().min(1),
 });
 const preToolUseInputSchema = hookCommonInputSchema.extend({
-    tool_name: z.string(),
+    tool_name: z.string().trim().min(1),
     tool_input: z.record(z.unknown()),
-    tool_use_id: z.string(),
+    tool_use_id: z.string().trim().min(1),
 });
 const subagentStartInputSchema = hookCommonInputSchema.extend({
-    agent_id: z.string(),
-    agent_type: z.string(),
+    agent_id: z.string().trim().min(1),
+    agent_type: z.string().trim().min(1),
 });
 const teammateIdleInputSchema = hookCommonInputSchema.extend({ teammate_name: z.string().optional(), });
 export { hookCommonInputSchema, preToolUseInputSchema, subagentStartInputSchema, teammateIdleInputSchema, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nt-ai-lab/deterministic-agent-workflow-cli",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "private": false,
   "type": "module",
   "repository": {
@@ -17,9 +17,9 @@
   ],
   "dependencies": {
     "zod": "^3.25.76",
-    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.4.0",
-    "@nt-ai-lab/deterministic-agent-workflow-dsl": "0.4.0",
-    "@nt-ai-lab/deterministic-agent-workflow-event-store": "0.4.0"
+    "@nt-ai-lab/deterministic-agent-workflow-dsl": "0.4.2",
+    "@nt-ai-lab/deterministic-agent-workflow-engine": "0.4.2",
+    "@nt-ai-lab/deterministic-agent-workflow-event-store": "0.4.2"
   },
   "devDependencies": {
     "vitest": "^2.1.9"