task-o-matic-core 0.1.0

package/dist/lib/executors/kilo-executor.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KiloExecutor = void 0;
+const node_child_process_1 = require("node:child_process");
+const logger_1 = require("../logger");
+class KiloExecutor {
+    name = "kilo";
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    supportsSessionResumption() {
+        return true;
+    }
+    async execute(message, dry = false, config) {
+        // Merge constructor config with execution config (execution takes precedence)
+        const finalConfig = { ...this.config, ...config };
+        // Build arguments array
+        const args = [];
+        // Add model if specified
+        if (finalConfig.model) {
+            args.push("-mo", finalConfig.model);
+            logger_1.logger.progress(`🤖 Using model: ${finalConfig.model}`);
+        }
+        // Add session resumption if specified
+        if (finalConfig.continueLastSession) {
+            args.push("-c");
+            logger_1.logger.progress("🔄 Continuing last session");
+        }
+        else if (finalConfig.sessionId) {
+            args.push("-s", finalConfig.sessionId);
+            logger_1.logger.progress(`🔄 Resuming session: ${finalConfig.sessionId}`);
+        }
+        // Run in autonomous mode (non-interactive) for automation
+        args.push("--auto");
+        // Enable auto-approval of all tool permissions
+        args.push("--yolo");
+        // Add prompt as positional argument
+        args.push(message);
+        if (dry) {
+            logger_1.logger.progress(`🔧 Using executor: ${this.name}`);
+            logger_1.logger.progress(`kilocode ${args.join(" ")}`);
+            return;
+        }
+        // Launch kilocode and wait for it to complete
+        const child = (0, node_child_process_1.spawn)("kilocode", args, {
+            stdio: "inherit", // Give tool full terminal control
+        });
+        // Wait for completion (blocking)
+        await new Promise((resolve, reject) => {
+            child.on("close", (code) => {
+                if (code === 0) {
+                    logger_1.logger.success("✅ Kilo Code execution completed successfully");
+                    resolve();
+                }
+                else {
+                    const error = new Error(`Kilo Code exited with code ${code}`);
+                    logger_1.logger.error(`❌ ${error.message}`);
+                    reject(error);
+                }
+            });
+            child.on("error", (error) => {
+                logger_1.logger.error(`❌ Failed to launch Kilo Code: ${error.message}`);
+                reject(error);
+            });
+        });
+    }
+}
+exports.KiloExecutor = KiloExecutor;

package/dist/lib/executors/opencode-executor.d.ts

@@ -0,0 +1,9 @@
+import type { ExecutorConfig, ExternalExecutor } from "../../types";
+export declare class OpencodeExecutor implements ExternalExecutor {
+    name: string;
+    private config?;
+    constructor(config?: ExecutorConfig);
+    supportsSessionResumption(): boolean;
+    execute(message: string, dry?: boolean, config?: ExecutorConfig): Promise<void>;
+}
+//# sourceMappingURL=opencode-executor.d.ts.map

package/dist/lib/executors/opencode-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencode-executor.d.ts","sourceRoot":"","sources":["../../../src/lib/executors/opencode-executor.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpE,qBAAa,gBAAiB,YAAW,gBAAgB;IACvD,IAAI,SAAc;IAClB,OAAO,CAAC,MAAM,CAAC,CAAiB;gBAEpB,MAAM,CAAC,EAAE,cAAc;IAInC,yBAAyB,IAAI,OAAO;IAI9B,OAAO,CACX,OAAO,EAAE,MAAM,EACf,GAAG,GAAE,OAAe,EACpB,MAAM,CAAC,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC;CA2DjB"}

package/dist/lib/executors/opencode-executor.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpencodeExecutor = void 0;
+const node_child_process_1 = require("node:child_process");
+const logger_1 = require("../logger");
+class OpencodeExecutor {
+    name = "opencode";
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    supportsSessionResumption() {
+        return true;
+    }
+    async execute(message, dry = false, config) {
+        // Merge constructor config with execution config (execution takes precedence)
+        const finalConfig = { ...this.config, ...config };
+        // Build arguments array
+        const args = [];
+        // Add model if specified
+        if (finalConfig.model) {
+            args.push("-m", finalConfig.model);
+            logger_1.logger.progress(`🤖 Using model: ${finalConfig.model}`);
+        }
+        // Add session resumption if specified
+        if (finalConfig.continueLastSession) {
+            args.push("-c");
+            logger_1.logger.progress("🔄 Continuing last session");
+        }
+        else if (finalConfig.sessionId) {
+            args.push("-s", finalConfig.sessionId);
+            logger_1.logger.progress(`🔄 Resuming session: ${finalConfig.sessionId}`);
+        }
+        // Use 'run' subcommand with message as positional argument
+        args.push("run", message);
+        if (dry) {
+            logger_1.logger.progress(`🔧 Using executor: ${this.name}`);
+            // Quote arguments that contain spaces for display
+            const quotedArgs = args.map((arg) => arg.includes(" ") ? `"${arg.replace(/"/g, '\\"')}"` : arg);
+            logger_1.logger.progress(`opencode ${quotedArgs.join(" ")}`);
+            return;
+        }
+        // Launch opencode and wait for it to complete
+        const child = (0, node_child_process_1.spawn)("opencode", args, {
+            stdio: "inherit", // Give tool full terminal control
+        });
+        // Wait for completion (blocking)
+        await new Promise((resolve, reject) => {
+            child.on("close", (code) => {
+                if (code === 0) {
+                    logger_1.logger.success("✅ Opencode execution completed successfully");
+                    resolve();
+                }
+                else {
+                    const error = new Error(`Opencode exited with code ${code}`);
+                    logger_1.logger.error(`❌ ${error.message}`);
+                    reject(error);
+                }
+            });
+            child.on("error", (error) => {
+                logger_1.logger.error(`❌ Failed to launch opencode: ${error.message}`);
+                reject(error);
+            });
+        });
+    }
+}
+exports.OpencodeExecutor = OpencodeExecutor;

package/dist/lib/git-utils.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Git state captured before and after execution
+ */
+export interface GitState {
+    beforeHead: string;
+    afterHead: string;
+    hasUncommittedChanges: boolean;
+}
+/**
+ * Commit information extracted from git state
+ */
+export interface CommitInfo {
+    message: string;
+    files: string[];
+}
+/**
+ * Check if new commits were made since a given HEAD
+ * Used to detect if the AI agent already committed during execution
+ */
+export declare function hasNewCommitsSince(beforeHead: string, execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>): Promise<boolean>;
+/**
+ * Capture git state (HEAD commit and uncommitted changes)
+ */
+export declare function captureGitState(execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>): Promise<Partial<GitState>>;
+/**
+ * Extract commit message and file list from git state
+ * This function analyzes the actual git state to generate appropriate commit info
+ */
+export declare function extractCommitInfo(taskId: string, taskTitle: string, executionMessage: string, gitState: GitState, execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>, aiOps?: any): Promise<CommitInfo>;
+/**
+ * Auto-commit changes using the provided commit info
+ */
+export declare function autoCommit(commitInfo: CommitInfo, execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>): Promise<void>;
+/**
+ * Commit a specific file with a custom message
+ */
+export declare function commitFile(filePath: string, message: string, execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>): Promise<void>;
+/**
+ * Check if the working directory is clean
+ */
+export declare function isClean(execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>): Promise<boolean>;
+/**
+ * Get the current branch name
+ */
+export declare function getCurrentBranch(execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>): Promise<string>;
+/**
+ * Create a new branch for benchmarking
+ */
+export declare function createBenchmarkBranch(name: string, baseBranch?: string, execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>): Promise<void>;
+/**
+ * Checkout an existing branch
+ */
+export declare function checkoutBranch(name: string, execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>): Promise<void>;
+/**
+ * Delete a benchmark branch (force delete)
+ */
+export declare function cleanupBenchmarkBranch(name: string, execFn?: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>): Promise<void>;
+//# sourceMappingURL=git-utils.d.ts.map

package/dist/lib/git-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-utils.d.ts","sourceRoot":"","sources":["../../src/lib/git-utils.ts"],"names":[],"mappings":"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"}

package/dist/lib/git-utils.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNewCommitsSince = hasNewCommitsSince;
+exports.captureGitState = captureGitState;
+exports.extractCommitInfo = extractCommitInfo;
+exports.autoCommit = autoCommit;
+exports.commitFile = commitFile;
+exports.isClean = isClean;
+exports.getCurrentBranch = getCurrentBranch;
+exports.createBenchmarkBranch = createBenchmarkBranch;
+exports.checkoutBranch = checkoutBranch;
+exports.cleanupBenchmarkBranch = cleanupBenchmarkBranch;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const logger_1 = require("./logger");
+const ai_service_factory_1 = require("../utils/ai-service-factory");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Check if new commits were made since a given HEAD
+ * Used to detect if the AI agent already committed during execution
+ */
+async function hasNewCommitsSince(beforeHead, execFn = execAsync) {
+    if (!beforeHead)
+        return false;
+    try {
+        const { stdout } = await execFn("git rev-parse HEAD");
+        return stdout.trim() !== beforeHead;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Capture git state (HEAD commit and uncommitted changes)
+ */
+async function captureGitState(execFn = execAsync) {
+    try {
+        const { stdout: headStdout } = await execFn("git rev-parse HEAD");
+        const { stdout: statusStdout } = await execFn("git status --porcelain");
+        return {
+            beforeHead: headStdout.trim(),
+            afterHead: headStdout.trim(),
+            hasUncommittedChanges: statusStdout.trim().length > 0,
+        };
+    }
+    catch (e) {
+        // Git might not be initialized or no commits yet
+        return {};
+    }
+}
+/**
+ * Extract commit message and file list from git state
+ * This function analyzes the actual git state to generate appropriate commit info
+ */
+async function extractCommitInfo(taskId, taskTitle, executionMessage, gitState, execFn = execAsync, aiOps = (0, ai_service_factory_1.getAIOperations)()) {
+    try {
+        // Case 1: Executor created a commit
+        if (gitState.beforeHead !== gitState.afterHead) {
+            logger_1.logger.info("📝 Executor created a commit, extracting info...");
+            const { stdout } = await execFn(`git show --stat --format="%s%n%b" ${gitState.afterHead}`);
+            const lines = stdout.trim().split("\n");
+            const message = lines[0].trim();
+            // Parse files from stat output (e.g. " src/file.ts | 10 +")
+            const files = lines
+                .slice(1)
+                .filter((line) => line.includes("|"))
+                .map((line) => line.split("|")[0].trim());
+            return {
+                message,
+                files,
+            };
+        }
+        // Case 2: Executor left uncommitted changes
+        if (gitState.hasUncommittedChanges) {
+            logger_1.logger.info("📝 Uncommitted changes detected, generating commit message...");
+            // Get the diff to send to AI
+            const { stdout: diff } = await execFn("git diff HEAD");
+            // Get list of changed files
+            const { stdout: status } = await execFn("git status --porcelain");
+            const files = status
+                .split("\n")
+                .filter((line) => line.length > 0)
+                .map((line) => line.substring(3).trim())
+                .filter((file) => file.length > 0);
+            // Use AI to generate commit message based on the diff
+            const prompt = `Based on the following git diff, generate a concise git commit message.
+
+Task: ${taskTitle}
+
+Git Diff:
+${diff.substring(0, 10000)} // Limit diff size
+
+Please respond in JSON format:
+{
+  "message": "concise commit message following conventional commits format"
+}
+
+The commit message should:
+- Follow conventional commits format (feat:, fix:, refactor:, etc.)
+- Be concise and descriptive
+- Focus on what changed
+`;
+            const response = await aiOps.streamText(prompt, undefined, "You are a helpful assistant that generates git commit messages.");
+            // Try to parse JSON from response
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            let message = `feat: complete task ${taskTitle}`;
+            if (jsonMatch) {
+                try {
+                    const parsed = JSON.parse(jsonMatch[0]);
+                    if (parsed.message) {
+                        message = parsed.message;
+                    }
+                }
+                catch (e) {
+                    // Ignore parse error
+                }
+            }
+            return {
+                message,
+                files,
+            };
+        }
+        // Case 3: No changes detected
+        return {
+            message: `feat: complete task ${taskTitle}`,
+            files: [],
+        };
+    }
+    catch (error) {
+        logger_1.logger.warn(`⚠️  Failed to extract commit info: ${error instanceof Error ? error.message : "Unknown error"}`);
+        // Fallback commit info
+        return {
+            message: `feat: complete task ${taskTitle}`,
+            files: [],
+        };
+    }
+}
+/**
+ * Auto-commit changes using the provided commit info
+ */
+async function autoCommit(commitInfo, execFn = execAsync) {
+    try {
+        const { message, files } = commitInfo;
+        if (files.length > 0) {
+            // Stage specific files
+            const gitAdd = `git add ${files.join(" ")}`;
+            logger_1.logger.info(`📦 Staging files: ${gitAdd}`);
+            await execFn(gitAdd);
+        }
+        else {
+            // Stage all changes
+            logger_1.logger.info("📦 Staging all changes");
+            await execFn("git add .");
+        }
+        // Commit
+        const gitCommit = `git commit -m "${message}"`;
+        logger_1.logger.info(`💾 Committing: ${message}`);
+        await execFn(gitCommit);
+        logger_1.logger.success("✅ Changes committed successfully\n");
+    }
+    catch (error) {
+        logger_1.logger.warn(`⚠️  Auto-commit failed: ${error instanceof Error ? error.message : "Unknown error"}\n`);
+    }
+}
+/**
+ * Commit a specific file with a custom message
+ */
+async function commitFile(filePath, message, execFn = execAsync) {
+    try {
+        logger_1.logger.info(`📦 Staging file: ${filePath}`);
+        await execFn(`git add ${filePath}`);
+        await execFn(`git commit -m "${message}"`);
+        logger_1.logger.success("✅ File committed successfully");
+    }
+    catch (e) {
+        logger_1.logger.warn(`⚠️  Failed to commit file: ${e instanceof Error ? e.message : "Unknown error"}`);
+    }
+}
+// ============================================================================
+// Benchmarking Git Utilities
+// ============================================================================
+/**
+ * Check if the working directory is clean
+ */
+async function isClean(execFn = execAsync) {
+    try {
+        const { stdout } = await execFn("git status --porcelain");
+        return stdout.trim().length === 0;
+    }
+    catch (error) {
+        logger_1.logger.warn("Could not check git status");
+        return false;
+    }
+}
+/**
+ * Get the current branch name
+ */
+async function getCurrentBranch(execFn = execAsync) {
+    try {
+        const { stdout } = await execFn("git rev-parse --abbrev-ref HEAD");
+        return stdout.trim();
+    }
+    catch (error) {
+        throw new Error("Failed to get current branch");
+    }
+}
+/**
+ * Create a new branch for benchmarking
+ */
+async function createBenchmarkBranch(name, baseBranch = "HEAD", execFn = execAsync) {
+    try {
+        logger_1.logger.info(`🌿 Creating benchmark branch: ${name} from ${baseBranch}`);
+        await execFn(`git checkout -b ${name} ${baseBranch}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to create benchmark branch ${name}: ${error}`);
+    }
+}
+/**
+ * Checkout an existing branch
+ */
+async function checkoutBranch(name, execFn = execAsync) {
+    try {
+        logger_1.logger.info(`🌿 Checking out branch: ${name}`);
+        await execFn(`git checkout ${name}`);
+    }
+    catch (error) {
+        throw new Error(`Failed to checkout branch ${name}: ${error}`);
+    }
+}
+/**
+ * Delete a benchmark branch (force delete)
+ */
+async function cleanupBenchmarkBranch(name, execFn = execAsync) {
+    try {
+        logger_1.logger.info(`🗑️  Deleting benchmark branch: ${name}`);
+        await execFn(`git branch -D ${name}`);
+    }
+    catch (error) {
+        logger_1.logger.warn(`Failed to delete branch ${name}: ${error}`);
+    }
+}

package/dist/lib/hooks.d.ts

@@ -0,0 +1,73 @@
+import { Task } from "../types";
+export type TaskEventType = "task:created" | "task:updated" | "task:deleted" | "task:status-changed" | "task:progress" | "execution:start" | "execution:end" | "execution:error" | "log:info" | "log:warn" | "log:error" | "log:success" | "log:progress";
+export interface LogEventPayload {
+    message: string;
+    context?: Record<string, unknown>;
+}
+export interface TaskEventPayloads {
+    "task:created": {
+        task: Task;
+    };
+    "task:updated": {
+        task: Task;
+        changes: Partial<Task>;
+    };
+    "task:deleted": {
+        taskId: string;
+    };
+    "task:status-changed": {
+        task: Task;
+        oldStatus: string;
+        newStatus: string;
+    };
+    "task:progress": {
+        taskId?: string;
+        message: string;
+        type?: string;
+    };
+    "execution:start": {
+        taskId: string;
+        tool: string;
+    };
+    "execution:end": {
+        taskId: string;
+        success: boolean;
+    };
+    "execution:error": {
+        taskId: string;
+        error: Error;
+    };
+    "log:info": LogEventPayload;
+    "log:warn": LogEventPayload;
+    "log:error": LogEventPayload;
+    "log:success": LogEventPayload;
+    "log:progress": LogEventPayload;
+}
+export type TaskEventHandler<T extends TaskEventType> = (payload: TaskEventPayloads[T]) => Promise<void> | void;
+declare class HookRegistry {
+    private static instance;
+    private listeners;
+    private constructor();
+    static getInstance(): HookRegistry;
+    /**
+     * Register a handler for a specific event type
+     */
+    on<T extends TaskEventType>(type: T, handler: TaskEventHandler<T>): void;
+    /**
+     * Remove a handler
+     */
+    off<T extends TaskEventType>(type: T, handler: TaskEventHandler<T>): void;
+    /**
+     * Emit an event to all registered handlers
+     * We don't await handlers to prevent blocking the main flow,
+     * but we catch errors to prevent crashes.
+     */
+    emit<T extends TaskEventType>(type: T, payload: TaskEventPayloads[T]): Promise<void>;
+    /**
+     * Clear all listeners (useful for testing)
+     */
+    clear(): void;
+}
+export declare const hooks: HookRegistry;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/lib/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/lib/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAGhC,MAAM,MAAM,aAAa,GACrB,cAAc,GACd,cAAc,GACd,cAAc,GACd,qBAAqB,GACrB,eAAe,GACf,iBAAiB,GACjB,eAAe,GACf,iBAAiB,GACjB,UAAU,GACV,UAAU,GACV,WAAW,GACX,aAAa,GACb,cAAc,CAAC;AAGnB,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAGD,MAAM,WAAW,iBAAiB;IAChC,cAAc,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC;IAC/B,cAAc,EAAE;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC;IACvD,cAAc,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,qBAAqB,EAAE;QAAE,IAAI,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAC5E,eAAe,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACrE,iBAAiB,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACpD,eAAe,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC;IACtD,iBAAiB,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAE,CAAC;IACpD,UAAU,EAAE,eAAe,CAAC;IAC5B,UAAU,EAAE,eAAe,CAAC;IAC5B,WAAW,EAAE,eAAe,CAAC;IAC7B,aAAa,EAAE,eAAe,CAAC;IAC/B,cAAc,EAAE,eAAe,CAAC;CACjC;AAGD,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,aAAa,IAAI,CACtD,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,KAC1B,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAE1B,cAAM,YAAY;IAChB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAe;IACtC,OAAO,CAAC,SAAS,CAAiD;IAElE,OAAO;WAIO,WAAW,IAAI,YAAY;IAOzC;;OAEG;IACI,EAAE,CAAC,CAAC,SAAS,aAAa,EAC/B,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC3B,IAAI;IAOP;;OAEG;IACI,GAAG,CAAC,CAAC,SAAS,aAAa,EAChC,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAC3B,IAAI;IAOP;;;;OAIG;IACU,IAAI,CAAC,CAAC,SAAS,aAAa,EACvC,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAC5B,OAAO,CAAC,IAAI,CAAC;IAiBhB;;OAEG;IACI,KAAK,IAAI,IAAI;CAGrB;AAED,eAAO,MAAM,KAAK,cAA6B,CAAC"}

package/dist/lib/hooks.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hooks = void 0;
+class HookRegistry {
+    static instance;
+    listeners;
+    constructor() {
+        this.listeners = new Map();
+    }
+    static getInstance() {
+        if (!HookRegistry.instance) {
+            HookRegistry.instance = new HookRegistry();
+        }
+        return HookRegistry.instance;
+    }
+    /**
+     * Register a handler for a specific event type
+     */
+    on(type, handler) {
+        if (!this.listeners.has(type)) {
+            this.listeners.set(type, new Set());
+        }
+        this.listeners.get(type).add(handler);
+    }
+    /**
+     * Remove a handler
+     */
+    off(type, handler) {
+        const handlers = this.listeners.get(type);
+        if (handlers) {
+            handlers.delete(handler);
+        }
+    }
+    /**
+     * Emit an event to all registered handlers
+     * We don't await handlers to prevent blocking the main flow,
+     * but we catch errors to prevent crashes.
+     */
+    async emit(type, payload) {
+        const handlers = this.listeners.get(type);
+        if (!handlers || handlers.size === 0)
+            return;
+        const promises = Array.from(handlers).map(async (handler) => {
+            try {
+                await handler(payload);
+            }
+            catch (error) {
+                // NOTE: Using console.error here intentionally - this is the hooks system
+                // that the logger depends on, so we can't use logger here (circular dependency)
+                console.error(`Error in hook handler for event ${type}:`, error);
+            }
+        });
+        await Promise.all(promises);
+    }
+    /**
+     * Clear all listeners (useful for testing)
+     */
+    clear() {
+        this.listeners.clear();
+    }
+}
+exports.hooks = HookRegistry.getInstance();