repoburg 1.3.159 → 1.3.161

package/backend/dist/src/seeding/data/tool-hooks/readme.js

@@ -13,6 +13,23 @@ You can configure these hooks in the "Tool Hooks" section of the Repoburg UI.
 2.  **Go to UI**: Open Repoburg -> Tool Hooks -> Add Hook.
 3.  **Configure**: Select the tool (e.g., \`patch\`), timing (\`before\` or \`after\`), and your script.
 
+## Wildcard Hooks
+
+You can use \`*\` as the tool name to create a hook that runs for **every** tool.
+Wildcard hooks always execute **before** tool-specific hooks.
+
+**Example:** A \`*\` before-hook runs before every tool action:
+
+| Hook Config | Execution Order |
+|-------------|----------------|
+| \`*\` before → \`audit.ts\` | Runs 1st |
+| \`create_file\` before → \`validate.ts\` | Runs 2nd |
+
+This is useful for:
+- **Logging/auditing** all tool actions
+- **Context size checks** before any action
+- **Global policies** that apply regardless of tool type
+
 ## Script Interface
 
 Your script must **export a default function** that receives the context.
@@ -24,7 +41,7 @@ interface HookContext {
   hook_type: 'before' | 'after';
   
   action: {
-    tool_name: string; // e.g. "patch"
+    tool_name: string; // e.g. "patch", or any tool name for wildcard hooks
     args: any;         // e.g. { file_path: "src/app.ts", patch_code: "..." }
     
     // Only present for 'after' hooks
@@ -35,7 +52,54 @@ interface HookContext {
     };
   };
 
-  plan_context: any; // Shared state of the current AI plan
+  plan_context: {
+    originalParsedActions: Array<{ tool_name: string; arguments: any }>;
+    feedback: {
+      validationErrors: Array<{ tool_name: string; error: string }>;
+      invalidToolErrors: Array<{ tool_name: string; arguments: any }>;
+    };
+    flags: {
+      should_halt: boolean;
+      halt_reason?: string;
+      is_final?: boolean;
+      follow_up_initiated?: boolean;
+    };
+  };
+
+  session: {
+    id: string; // Current session ID
+  };
+
+  api: {
+    // Get the token count of the current session's conversation history
+    getContextSize(): Promise<number>;
+
+    // Invoke a sub-agent synchronously (blocks until the sub-agent completes)
+    invokeSubAgent(agentName: string, prompt: string, options?: { sessionId?: string }): Promise<{
+      content: string;
+      success: boolean;
+      childSessionId: string;
+      iterations: number;
+    }>;
+
+    // Get session status: message count, token estimates, grouped message summaries
+    getSessionStatus(): Promise<{
+      message_count: number;
+      total_est_tokens: number;
+      groups: Array<{
+        label: string;
+        label_suffix: string;
+        message_count: number;
+        est_tokens: number;
+        messages: Array<{
+          role: string;
+          preview: string;
+          thoughts?: string;
+          est_tokens: number;
+        }>;
+      }>;
+    }>;
+  };
 }
 \`\`\`
 
@@ -55,5 +119,35 @@ interface HookOutput {
   update_context?: Record<string, any>;
 }
 \`\`\`
+
+### Examples
+
+**Block edits to locked files (wildcard hook):**
+
+\`\`\`typescript
+export default async function(context: HookContext): Promise<HookOutput> {
+  const filePath = context.action?.args?.file_path || '';
+  if (filePath.includes('lock')) {
+    return {
+      should_halt_plan: true,
+      message: 'BLOCKED: Editing locked files is forbidden.'
+    };
+  }
+  return { should_halt_plan: false };
+}
+\`\`\`
+
+**Auto-compress context when it grows too large (wildcard hook):**
+
+\`\`\`typescript
+export default async function(context: HookContext): Promise<HookOutput> {
+  const status = await context.api.getSessionStatus();
+  if (status.total_est_tokens > 70000) {
+    const result = await context.api.invokeSubAgent('compress-agent', 'Compress conversation history');
+    return { message: 'Context was ' + status.total_est_tokens + ' tokens. Compressed.' };
+  }
+  return { should_halt_plan: false };
+}
+\`\`\`
 `;
 //# sourceMappingURL=readme.js.map

package/backend/dist/src/seeding/data/tool-hooks/readme.js.map

@@ -1 +1 @@
-{"version":3,"file":"readme.js","sourceRoot":"","sources":["../../../../../src/seeding/data/tool-hooks/readme.ts"],"names":[],"mappings":";;;AAAa,QAAA,QAAQ,GAAG,WAAW,CAAC;AACvB,QAAA,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDtB,CAAC"}
+{"version":3,"file":"readme.js","sourceRoot":"","sources":["../../../../../src/seeding/data/tool-hooks/readme.ts"],"names":[],"mappings":";;;AAAa,QAAA,QAAQ,GAAG,WAAW,CAAC;AACvB,QAAA,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmJtB,CAAC"}

package/backend/dist/src/tool-hooks/hook-context.interface.d.ts

@@ -0,0 +1,76 @@
+export interface HookAction {
+    tool_name: string;
+    args: Record<string, any>;
+    result?: {
+        status: 'SUCCESS' | 'FAILURE';
+        output?: string;
+        error?: string;
+    };
+}
+export interface HookPlanContext {
+    originalParsedActions: Array<{
+        tool_name: string;
+        arguments: any;
+    }>;
+    feedback: {
+        validationErrors: Array<{
+            tool_name: string;
+            error: string;
+        }>;
+        invalidToolErrors: Array<{
+            tool_name: string;
+            arguments: any;
+        }>;
+    };
+    flags: {
+        should_halt: boolean;
+        halt_reason?: string;
+        is_final?: boolean;
+        follow_up_initiated?: boolean;
+    };
+}
+export interface HookSession {
+    id: string;
+}
+export interface HookSubAgentResult {
+    content: string;
+    success: boolean;
+    childSessionId: string;
+    iterations: number;
+}
+export interface HookApi {
+    getContextSize(): Promise<number>;
+    invokeSubAgent(agentName: string, prompt: string, options?: {
+        sessionId?: string;
+    }): Promise<HookSubAgentResult>;
+    getSessionStatus(): Promise<HookSessionStatus>;
+}
+export interface HookSessionStatusGroup {
+    label: string;
+    label_suffix: string;
+    message_count: number;
+    est_tokens: number;
+    messages: Array<{
+        role: string;
+        preview: string;
+        thoughts?: string;
+        est_tokens: number;
+    }>;
+}
+export interface HookSessionStatus {
+    message_count: number;
+    total_est_tokens: number;
+    groups: HookSessionStatusGroup[];
+}
+export interface HookContext {
+    hook_type: 'before' | 'after';
+    action: HookAction;
+    plan_context: HookPlanContext;
+    session: HookSession;
+    api: HookApi;
+}
+export interface HookOutput {
+    should_halt_plan?: boolean;
+    message?: string;
+    update_context?: Record<string, any>;
+}

package/backend/dist/src/tool-hooks/hook-context.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=hook-context.interface.js.map

package/backend/dist/src/tool-hooks/hook-context.interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook-context.interface.js","sourceRoot":"","sources":["../../../src/tool-hooks/hook-context.interface.ts"],"names":[],"mappings":""}

package/backend/dist/src/tool-hooks/hook-runtime.d.ts

@@ -0,0 +1,26 @@
+import { HookApi, HookSessionStatus, HookSubAgentResult } from './hook-context.interface';
+export type HistoryProvider = (sessionId: string) => Promise<Array<{
+    parts: Array<{
+        text: string;
+    }>;
+    role: string;
+}>>;
+export type SubAgentInvoker = (agentName: string, prompt: string, parentSessionId: string, options?: {
+    sessionId?: string;
+}) => Promise<HookSubAgentResult>;
+export type SessionStatusProvider = (sessionId: string) => Promise<HookSessionStatus>;
+export declare class HookRuntime {
+    private readonly logger;
+    private sessionId;
+    private historyProvider;
+    private subAgentInvoker;
+    private sessionStatusProvider;
+    setSessionId(sessionId: string): void;
+    setHistoryProvider(provider: HistoryProvider): void;
+    setSubAgentInvoker(invoker: SubAgentInvoker): void;
+    setSessionStatusProvider(provider: SessionStatusProvider): void;
+    createApi(): HookApi;
+    private getContextSize;
+    private invokeSubAgent;
+    private getSessionStatus;
+}

package/backend/dist/src/tool-hooks/hook-runtime.js

@@ -0,0 +1,105 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var HookRuntime_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookRuntime = void 0;
+const common_1 = require("@nestjs/common");
+const gpt_tokenizer_1 = require("gpt-tokenizer");
+let HookRuntime = HookRuntime_1 = class HookRuntime {
+    constructor() {
+        this.logger = new common_1.Logger(HookRuntime_1.name);
+        this.historyProvider = null;
+        this.subAgentInvoker = null;
+        this.sessionStatusProvider = null;
+    }
+    setSessionId(sessionId) {
+        this.sessionId = sessionId;
+    }
+    setHistoryProvider(provider) {
+        this.historyProvider = provider;
+    }
+    setSubAgentInvoker(invoker) {
+        this.subAgentInvoker = invoker;
+    }
+    setSessionStatusProvider(provider) {
+        this.sessionStatusProvider = provider;
+    }
+    createApi() {
+        return {
+            getContextSize: async () => {
+                return this.getContextSize();
+            },
+            invokeSubAgent: async (agentName, prompt, options) => {
+                return this.invokeSubAgent(agentName, prompt, options);
+            },
+            getSessionStatus: async () => {
+                return this.getSessionStatus();
+            },
+        };
+    }
+    async getContextSize() {
+        if (!this.sessionId) {
+            throw new Error('HookRuntime: sessionId not set. Cannot compute context size.');
+        }
+        if (!this.historyProvider) {
+            throw new Error('HookRuntime: historyProvider not set. Cannot compute context size.');
+        }
+        try {
+            const history = await this.historyProvider(this.sessionId);
+            const text = history
+                .map((h) => h.parts.map((p) => p.text).join(''))
+                .join(' ');
+            return (0, gpt_tokenizer_1.countTokens)(text);
+        }
+        catch (error) {
+            this.logger.error(`HookRuntime: Failed to compute context size for session ${this.sessionId}: ${error.message}`);
+            throw error;
+        }
+    }
+    async invokeSubAgent(agentName, prompt, options) {
+        if (!this.sessionId) {
+            throw new Error('HookRuntime: sessionId not set. Cannot invoke sub-agent.');
+        }
+        if (!this.subAgentInvoker) {
+            throw new Error('HookRuntime: subAgentInvoker not set. Cannot invoke sub-agent.');
+        }
+        try {
+            const result = await this.subAgentInvoker(agentName, prompt, this.sessionId, options?.sessionId ? { sessionId: options.sessionId } : undefined);
+            return result;
+        }
+        catch (error) {
+            this.logger.error(`HookRuntime: invokeSubAgent failed for agent "${agentName}": ${error.message}`);
+            return {
+                content: `Sub-agent invocation failed: ${error.message}`,
+                success: false,
+                childSessionId: '',
+                iterations: 0,
+            };
+        }
+    }
+    async getSessionStatus() {
+        if (!this.sessionId) {
+            throw new Error('HookRuntime: sessionId not set. Cannot get session status.');
+        }
+        if (!this.sessionStatusProvider) {
+            throw new Error('HookRuntime: sessionStatusProvider not set. Cannot get session status.');
+        }
+        try {
+            return await this.sessionStatusProvider(this.sessionId);
+        }
+        catch (error) {
+            this.logger.error(`HookRuntime: getSessionStatus failed for session ${this.sessionId}: ${error.message}`);
+            throw error;
+        }
+    }
+};
+exports.HookRuntime = HookRuntime;
+exports.HookRuntime = HookRuntime = HookRuntime_1 = __decorate([
+    (0, common_1.Injectable)()
+], HookRuntime);
+//# sourceMappingURL=hook-runtime.js.map

package/backend/dist/src/tool-hooks/hook-runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook-runtime.js","sourceRoot":"","sources":["../../../src/tool-hooks/hook-runtime.ts"],"names":[],"mappings":"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"}

package/backend/dist/src/tool-hooks/tool-hooks.module.js

@@ -12,6 +12,7 @@ const typeorm_1 = require("@nestjs/typeorm");
 const core_entities_1 = require("../core-entities");
 const tool_hooks_controller_1 = require("./tool-hooks.controller");
 const tool_hooks_service_1 = require("./tool-hooks.service");
+const hook_runtime_1 = require("./hook-runtime");
 const execution_logs_module_1 = require("../execution-logs/execution-logs.module");
 let ToolHooksModule = class ToolHooksModule {
 };
@@ -20,8 +21,8 @@ exports.ToolHooksModule = ToolHooksModule = __decorate([
     (0, common_1.Module)({
         imports: [typeorm_1.TypeOrmModule.forFeature([core_entities_1.ToolHook]), execution_logs_module_1.ExecutionLogsModule],
         controllers: [tool_hooks_controller_1.ToolHooksController],
-        providers: [tool_hooks_service_1.ToolHooksService],
-        exports: [tool_hooks_service_1.ToolHooksService],
+        providers: [tool_hooks_service_1.ToolHooksService, hook_runtime_1.HookRuntime],
+        exports: [tool_hooks_service_1.ToolHooksService, hook_runtime_1.HookRuntime],
     })
 ], ToolHooksModule);
 //# sourceMappingURL=tool-hooks.module.js.map

package/backend/dist/src/tool-hooks/tool-hooks.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"tool-hooks.module.js","sourceRoot":"","sources":["../../../src/tool-hooks/tool-hooks.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,6CAAgD;AAChD,oDAA4C;AAC5C,mEAA8D;AAC9D,6DAAwD;AACxD,mFAA8E;AAQvE,IAAM,eAAe,GAArB,MAAM,eAAe;CAAG,CAAA;AAAlB,0CAAe;0BAAf,eAAe;IAN3B,IAAA,eAAM,EAAC;QACN,OAAO,EAAE,CAAC,uBAAa,CAAC,UAAU,CAAC,CAAC,wBAAQ,CAAC,CAAC,EAAE,2CAAmB,CAAC;QACpE,WAAW,EAAE,CAAC,2CAAmB,CAAC;QAClC,SAAS,EAAE,CAAC,qCAAgB,CAAC;QAC7B,OAAO,EAAE,CAAC,qCAAgB,CAAC;KAC5B,CAAC;GACW,eAAe,CAAG"}
+{"version":3,"file":"tool-hooks.module.js","sourceRoot":"","sources":["../../../src/tool-hooks/tool-hooks.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,6CAAgD;AAChD,oDAA4C;AAC5C,mEAA8D;AAC9D,6DAAwD;AACxD,iDAA6C;AAC7C,mFAA8E;AAQvE,IAAM,eAAe,GAArB,MAAM,eAAe;CAAG,CAAA;AAAlB,0CAAe;0BAAf,eAAe;IAN3B,IAAA,eAAM,EAAC;QACN,OAAO,EAAE,CAAC,uBAAa,CAAC,UAAU,CAAC,CAAC,wBAAQ,CAAC,CAAC,EAAE,2CAAmB,CAAC;QACpE,WAAW,EAAE,CAAC,2CAAmB,CAAC;QAClC,SAAS,EAAE,CAAC,qCAAgB,EAAE,0BAAW,CAAC;QAC1C,OAAO,EAAE,CAAC,qCAAgB,EAAE,0BAAW,CAAC;KACzC,CAAC;GACW,eAAe,CAAG"}

package/backend/dist/src/tool-hooks/tool-hooks.service.d.ts

@@ -2,12 +2,15 @@ import { Repository } from 'typeorm';
 import { ToolHook } from '../core-entities';
 import { CreateToolHookDto } from './dto/create-tool-hook.dto';
 import { UpdateToolHookDto } from './dto/update-tool-hook.dto';
+import { HookRuntime } from './hook-runtime';
+import { HookContext, HookOutput } from './hook-context.interface';
 export declare class ToolHooksService {
     private readonly toolHooksRepository;
+    private readonly hookRuntime;
     private readonly logger;
     private readonly projectRoot;
     private readonly hooksDir;
-    constructor(toolHooksRepository: Repository<ToolHook>);
+    constructor(toolHooksRepository: Repository<ToolHook>, hookRuntime: HookRuntime);
     private ensureHooksDir;
     private createExampleFiles;
     findAll(): Promise<ToolHook[]>;
@@ -22,7 +25,11 @@ export declare class ToolHooksService {
     private getArgsInterface;
     generateSamplePayload(toolName: string, timing: 'before' | 'after'): any;
     private getSampleArgs;
-    executeHook(scriptFilename: string, payload: any): Promise<any>;
+    executeHook(scriptFilename: string, payload: HookContext): Promise<HookOutput>;
+    executeHookWithLogs(scriptFilename: string, payload: HookContext): Promise<{
+        result: HookOutput;
+        logs: string[];
+    }>;
     testHook(scriptFilename: string, payload: any): Promise<{
         result: any;
         logs: string[];

package/backend/dist/src/tool-hooks/tool-hooks.service.js

@@ -18,15 +18,16 @@ const common_1 = require("@nestjs/common");
 const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
 const core_entities_1 = require("../core-entities");
+const hook_runtime_1 = require("./hook-runtime");
 const fs = require("fs/promises");
 const path = require("path");
-const vm = require("vm");
 const readmeData = require("../seeding/data/tool-hooks/readme");
 const exampleHookData = require("../seeding/data/tool-hooks/example-hook");
 const eslintHookData = require("../seeding/data/tool-hooks/eslint-hook");
 let ToolHooksService = ToolHooksService_1 = class ToolHooksService {
-    constructor(toolHooksRepository) {
+    constructor(toolHooksRepository, hookRuntime) {
         this.toolHooksRepository = toolHooksRepository;
+        this.hookRuntime = hookRuntime;
         this.logger = new common_1.Logger(ToolHooksService_1.name);
         this.projectRoot = process.env.REPOBURG_PROJECT_PATH || process.cwd();
         this.hooksDir = path.join(this.projectRoot, '.repoburg', 'hooks');
@@ -73,8 +74,18 @@ let ToolHooksService = ToolHooksService_1 = class ToolHooksService {
         await this.toolHooksRepository.delete(id);
     }
     async findByTrigger(toolName, timing) {
-        return this.toolHooksRepository.find({
-            where: { tool_name: toolName, timing, is_active: true },
+        const hooks = await this.toolHooksRepository.find({
+            where: [
+                { tool_name: toolName, timing, is_active: true },
+                { tool_name: '*', timing, is_active: true },
+            ],
+        });
+        return hooks.sort((a, b) => {
+            if (a.tool_name === '*' && b.tool_name !== '*')
+                return -1;
+            if (a.tool_name !== '*' && b.tool_name === '*')
+                return 1;
+            return 0;
         });
     }
     async listScripts() {
@@ -94,18 +105,30 @@ let ToolHooksService = ToolHooksService_1 = class ToolHooksService {
         await fs.writeFile(scriptPath, content, 'utf-8');
     }
     generateTemplate(toolName) {
+        const isWildcard = toolName === '*';
         const argsType = this.getArgsInterface(toolName);
+        const pascalName = isWildcard ? 'AnyTool' : this.pascalCase(toolName);
         return `/**
- * Hook for tool: ${toolName}
+ * Hook for tool: ${isWildcard ? 'any tool (wildcard)' : toolName}
  */
 
 // --- Type Definitions ---
 
-export interface ${this.pascalCase(toolName)}Args {
+export interface ${pascalName}Args {
 ${argsType}
 }
 
-export interface PlanContext {
+export interface HookAction {
+  tool_name: ${isWildcard ? 'string' : `'${toolName}'`};
+  args: ${pascalName}Args;
+  result?: {
+    status: 'SUCCESS' | 'FAILURE';
+    output?: string;
+    error?: string;
+  };
+}
+
+export interface HookPlanContext {
   originalParsedActions: Array<{ tool_name: string; arguments: any }>;
   feedback: {
     validationErrors: Array<{ tool_name: string; error: string }>;
@@ -114,26 +137,56 @@ export interface PlanContext {
   flags: {
     should_halt: boolean;
     halt_reason?: string;
-    is_final: boolean;
-    follow_up_initiated: boolean;
+    is_final?: boolean;
+    follow_up_initiated?: boolean;
   };
 }
 
-export interface HookAction {
-  tool_name: '${toolName}';
-  args: ${this.pascalCase(toolName)}Args;
-  // Only present for 'after' hooks
-  result?: {
-    status: 'SUCCESS' | 'FAILURE';
-    output?: string;
-    error?: string;
-  };
+export interface HookSession {
+  id: string;
+}
+
+export interface HookSubAgentResult {
+  content: string;
+  success: boolean;
+  childSessionId: string;
+  iterations: number;
+}
+
+export interface HookSessionStatusGroup {
+  label: string;
+  label_suffix: string;
+  message_count: number;
+  est_tokens: number;
+  messages: Array<{
+    role: string;
+    preview: string;
+    thoughts?: string;
+    est_tokens: number;
+  }>;
+}
+
+export interface HookSessionStatus {
+  message_count: number;
+  total_est_tokens: number;
+  groups: HookSessionStatusGroup[];
+}
+
+export interface HookApi {
+  /** Get the current context size in tokens for the session */
+  getContextSize(): Promise<number>;
+  /** Invoke a sub-agent synchronously (blocks until complete) */
+  invokeSubAgent(agentName: string, prompt: string, options?: { sessionId?: string }): Promise<HookSubAgentResult>;
+  /** Get session status: message count, token estimates, grouped message summaries */
+  getSessionStatus(): Promise<HookSessionStatus>;
 }
 
 export interface HookContext {
   hook_type: 'before' | 'after';
   action: HookAction;
-  plan_context: PlanContext; 
+  plan_context: HookPlanContext;
+  session: HookSession;
+  api: HookApi;
 }
 
 export interface HookOutput {
@@ -146,8 +199,13 @@ export interface HookOutput {
 
 export default async function(context: HookContext): Promise<HookOutput | void> {
   const { args } = context.action;
-  
-  // Add your hook logic here
+
+  // Example: Check session status and compress if too large
+  // const status = await context.api.getSessionStatus();
+  // if (status.total_est_tokens > 70000) {
+  //   const result = await context.api.invokeSubAgent('compress-agent', 'Compress conversation history');
+  //   return { message: \`Compressed from \${status.total_est_tokens} tokens\` };
+  // }
 
   return {
     should_halt_plan: false
@@ -163,6 +221,9 @@ export default async function(context: HookContext): Promise<HookOutput | void>
     }
     getArgsInterface(toolName) {
         switch (toolName) {
+            case '*':
+                return `  // Wildcard hooks receive args for any tool
+  [key: string]: any;`;
             case 'patch':
                 return `  file_path: string;
   patch_code: string;`;
@@ -208,13 +269,22 @@ export default async function(context: HookContext): Promise<HookOutput | void>
                     : {}),
             },
             plan_context: {
+                originalParsedActions: [{ tool_name: toolName, arguments: sampleArgs }],
                 flags: { should_halt: false },
-                feedback: { validationErrors: [] },
+                feedback: { validationErrors: [], invalidToolErrors: [] },
+            },
+            session: { id: 'sample-session-id' },
+            api: {
+                getContextSize: '[async function] Returns token count of session history.',
+                invokeSubAgent: '[async function] Invokes a sub-agent and returns result.',
+                getSessionStatus: '[async function] Returns session status with message count, token estimates, and grouped summaries.',
             },
         };
     }
     getSampleArgs(toolName) {
         switch (toolName) {
+            case '*':
+                return { file_path: 'src/example.ts', content: '// example' };
             case 'patch':
                 return { file_path: 'src/main.ts', patch_code: '// ... code ...' };
             case 'create_file':
@@ -240,6 +310,34 @@ export default async function(context: HookContext): Promise<HookOutput | void>
     async executeHook(scriptFilename, payload) {
         return this.runScript(scriptFilename, payload, console);
     }
+    async executeHookWithLogs(scriptFilename, payload) {
+        const logs = [];
+        const mockConsole = {
+            log: (...args) => logs.push(args
+                .map((a) => (typeof a === 'object' ? JSON.stringify(a) : String(a)))
+                .join(' ')),
+            error: (...args) => logs.push('[ERROR] ' +
+                args
+                    .map((a) => typeof a === 'object' ? JSON.stringify(a) : String(a))
+                    .join(' ')),
+            warn: (...args) => logs.push('[WARN] ' +
+                args
+                    .map((a) => typeof a === 'object' ? JSON.stringify(a) : String(a))
+                    .join(' ')),
+            info: (...args) => logs.push('[INFO] ' +
+                args
+                    .map((a) => typeof a === 'object' ? JSON.stringify(a) : String(a))
+                    .join(' ')),
+        };
+        try {
+            const result = await this.runScript(scriptFilename, payload, mockConsole);
+            return { result, logs };
+        }
+        catch (e) {
+            logs.push(`[SYSTEM ERROR] ${e.message}`);
+            throw e;
+        }
+    }
     async testHook(scriptFilename, payload) {
         const logs = [];
         const mockConsole = {
@@ -293,16 +391,8 @@ export default async function(context: HookContext): Promise<HookOutput | void>
                 },
             });
             const moduleRef = { exports: {} };
-            const sandbox = {
-                module: moduleRef,
-                exports: moduleRef.exports,
-                require: require,
-                console: consoleEnv,
-                process: process,
-            };
-            const context = vm.createContext(sandbox);
-            const script = new vm.Script(outputText);
-            script.runInContext(context);
+            const moduleFunc = new Function('module', 'exports', 'require', 'console', 'process', '__filename', '__dirname', outputText);
+            moduleFunc(moduleRef, moduleRef.exports, require, consoleEnv, process, scriptPath, this.hooksDir);
             const exported = moduleRef.exports;
             const defaultExport = exported.default || exported;
             if (typeof defaultExport !== 'function') {
@@ -321,6 +411,8 @@ exports.ToolHooksService = ToolHooksService;
 exports.ToolHooksService = ToolHooksService = ToolHooksService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, typeorm_1.InjectRepository)(core_entities_1.ToolHook)),
-    __metadata("design:paramtypes", [typeorm_2.Repository])
+    __param(1, (0, common_1.Inject)((0, common_1.forwardRef)(() => hook_runtime_1.HookRuntime))),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        hook_runtime_1.HookRuntime])
 ], ToolHooksService);
 //# sourceMappingURL=tool-hooks.service.js.map