@yagr/agent 0.1.0

package/dist/tools/manage-workflow.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { Engine } from '../engine/engine.js';
+export declare function createManageWorkflowTool(engine: Engine): import("ai").Tool<z.ZodObject<{
+    workflowId: z.ZodString;
+    action: z.ZodEnum<["activate", "deactivate", "delete"]>;
+}, "strip", z.ZodTypeAny, {
+    action: "activate" | "deactivate" | "delete";
+    workflowId: string;
+}, {
+    action: "activate" | "deactivate" | "delete";
+    workflowId: string;
+}>, {
+    workflowId: string;
+    action: "activate";
+    ok: boolean;
+} | {
+    workflowId: string;
+    action: "deactivate";
+    ok: boolean;
+} | {
+    workflowId: string;
+    action: "delete";
+    ok: boolean;
+}> & {
+    execute: (args: {
+        action: "activate" | "deactivate" | "delete";
+        workflowId: string;
+    }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+        workflowId: string;
+        action: "activate";
+        ok: boolean;
+    } | {
+        workflowId: string;
+        action: "deactivate";
+        ok: boolean;
+    } | {
+        workflowId: string;
+        action: "delete";
+        ok: boolean;
+    }>;
+};
+//# sourceMappingURL=manage-workflow.d.ts.map

package/dist/tools/manage-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manage-workflow.d.ts","sourceRoot":"","sources":["../../src/tools/manage-workflow.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBtD"}

package/dist/tools/manage-workflow.js

@@ -0,0 +1,26 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+export function createManageWorkflowTool(engine) {
+    return tool({
+        description: 'Activate, deactivate, or delete an existing workflow.',
+        parameters: z.object({
+            workflowId: z.string().min(1),
+            action: z.enum(['activate', 'deactivate', 'delete']),
+        }),
+        execute: async ({ workflowId, action }) => {
+            switch (action) {
+                case 'activate':
+                    await engine.activateWorkflow(workflowId);
+                    return { workflowId, action, ok: true };
+                case 'deactivate':
+                    await engine.deactivateWorkflow(workflowId);
+                    return { workflowId, action, ok: true };
+                case 'delete':
+                    await engine.deleteWorkflow(workflowId);
+                    return { workflowId, action, ok: true };
+            }
+            throw new Error(`Unsupported workflow action: ${action}`);
+        },
+    });
+}
+//# sourceMappingURL=manage-workflow.js.map

package/dist/tools/manage-workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manage-workflow.js","sourceRoot":"","sources":["../../src/tools/manage-workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAC1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,UAAU,wBAAwB,CAAC,MAAc;IACrD,OAAO,IAAI,CAAC;QACV,WAAW,EAAE,uDAAuD;QACpE,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC;YACnB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;YAC7B,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE,YAAY,EAAE,QAAQ,CAAC,CAAC;SACrD,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE;YACxC,QAAQ,MAAM,EAAE,CAAC;gBACf,KAAK,UAAU;oBACb,MAAM,MAAM,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;oBAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;gBAC1C,KAAK,YAAY;oBACf,MAAM,MAAM,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC;oBAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;gBAC1C,KAAK,QAAQ;oBACX,MAAM,MAAM,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;oBACxC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;YAC5C,CAAC;YAED,MAAM,IAAI,KAAK,CAAC,gCAAgC,MAAM,EAAE,CAAC,CAAC;QAC5D,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/tools/move-workspace-file.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import type { ToolExecutionObserver } from './observer.js';
+export declare function createMoveWorkspaceFileTool(_observer?: ToolExecutionObserver): import("ai").Tool<z.ZodObject<{
+    fromPath: z.ZodString;
+    toPath: z.ZodString;
+    overwrite: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    fromPath: string;
+    toPath: string;
+    overwrite: boolean;
+}, {
+    fromPath: string;
+    toPath: string;
+    overwrite?: boolean | undefined;
+}>, {
+    ok: boolean;
+    fromPath: string;
+    toPath: string;
+    error: string;
+} | {
+    ok: boolean;
+    fromPath: string;
+    toPath: string;
+    error?: undefined;
+}> & {
+    execute: (args: {
+        fromPath: string;
+        toPath: string;
+        overwrite: boolean;
+    }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+        ok: boolean;
+        fromPath: string;
+        toPath: string;
+        error: string;
+    } | {
+        ok: boolean;
+        fromPath: string;
+        toPath: string;
+        error?: undefined;
+    }>;
+};
+//# sourceMappingURL=move-workspace-file.d.ts.map

package/dist/tools/move-workspace-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-workspace-file.d.ts","sourceRoot":"","sources":["../../src/tools/move-workspace-file.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAG3D,wBAAgB,2BAA2B,CAAC,SAAS,CAAC,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4C5E"}

package/dist/tools/move-workspace-file.js

@@ -0,0 +1,45 @@
+import fs from 'node:fs';
+import { tool } from 'ai';
+import { z } from 'zod';
+import { ensureParentDirectory, fileExists, relativeWorkspacePath, resolveWorkspacePath } from './workspace-utils.js';
+export function createMoveWorkspaceFileTool(_observer) {
+    return tool({
+        description: 'Move or rename a workspace file to a canonical path. Use this to consolidate provisional artifacts into the correct location before completion.',
+        parameters: z.object({
+            fromPath: z.string().min(1).describe('Current workspace-relative file path.'),
+            toPath: z.string().min(1).describe('Target workspace-relative file path.'),
+            overwrite: z.boolean().default(false).describe('Whether to overwrite the destination if it already exists.'),
+        }),
+        execute: async ({ fromPath, toPath, overwrite }) => {
+            const sourcePath = resolveWorkspacePath(fromPath);
+            const targetPath = resolveWorkspacePath(toPath);
+            if (!fileExists(sourcePath)) {
+                return {
+                    ok: false,
+                    fromPath: relativeWorkspacePath(sourcePath),
+                    toPath: relativeWorkspacePath(targetPath),
+                    error: `Source file does not exist: ${fromPath}`,
+                };
+            }
+            if (!overwrite && fileExists(targetPath)) {
+                return {
+                    ok: false,
+                    fromPath: relativeWorkspacePath(sourcePath),
+                    toPath: relativeWorkspacePath(targetPath),
+                    error: `Destination already exists: ${toPath}`,
+                };
+            }
+            ensureParentDirectory(targetPath);
+            if (overwrite && fileExists(targetPath)) {
+                fs.rmSync(targetPath, { force: true });
+            }
+            fs.renameSync(sourcePath, targetPath);
+            return {
+                ok: true,
+                fromPath: relativeWorkspacePath(sourcePath),
+                toPath: relativeWorkspacePath(targetPath),
+            };
+        },
+    });
+}
+//# sourceMappingURL=move-workspace-file.js.map

package/dist/tools/move-workspace-file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"move-workspace-file.js","sourceRoot":"","sources":["../../src/tools/move-workspace-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAC1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEtH,MAAM,UAAU,2BAA2B,CAAC,SAAiC;IAC3E,OAAO,IAAI,CAAC;QACV,WAAW,EAAE,iJAAiJ;QAC9J,UAAU,EAAE,CAAC,CAAC,MAAM,CAAC;YACnB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,uCAAuC,CAAC;YAC7E,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,sCAAsC,CAAC;YAC1E,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,QAAQ,CAAC,4DAA4D,CAAC;SAC7G,CAAC;QACF,OAAO,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE;YACjD,MAAM,UAAU,GAAG,oBAAoB,CAAC,QAAQ,CAAC,CAAC;YAClD,MAAM,UAAU,GAAG,oBAAoB,CAAC,MAAM,CAAC,CAAC;YAEhD,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;gBAC5B,OAAO;oBACL,EAAE,EAAE,KAAK;oBACT,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC;oBAC3C,MAAM,EAAE,qBAAqB,CAAC,UAAU,CAAC;oBACzC,KAAK,EAAE,+BAA+B,QAAQ,EAAE;iBACjD,CAAC;YACJ,CAAC;YAED,IAAI,CAAC,SAAS,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;gBACzC,OAAO;oBACL,EAAE,EAAE,KAAK;oBACT,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC;oBAC3C,MAAM,EAAE,qBAAqB,CAAC,UAAU,CAAC;oBACzC,KAAK,EAAE,+BAA+B,MAAM,EAAE;iBAC/C,CAAC;YACJ,CAAC;YAED,qBAAqB,CAAC,UAAU,CAAC,CAAC;YAClC,IAAI,SAAS,IAAI,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;gBACxC,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;YACzC,CAAC;YAED,EAAE,CAAC,UAAU,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;YAEtC,OAAO;gBACL,EAAE,EAAE,IAAI;gBACR,QAAQ,EAAE,qBAAqB,CAAC,UAAU,CAAC;gBAC3C,MAAM,EAAE,qBAAqB,CAAC,UAAU,CAAC;aAC1C,CAAC;QACJ,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/tools/n8nac.d.ts

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+import { type ToolExecutionObserver } from './observer.js';
+export declare function createN8nAcTool(observer?: ToolExecutionObserver): import("ai").Tool<z.ZodObject<{
+    action: z.ZodEnum<["setup_check", "init_auth", "init_project", "list", "pull", "push", "verify", "skills", "validate", "update_ai", "resolve", "skillsArgs", "skillsArgv"]>;
+    n8nHost: z.ZodOptional<z.ZodString>;
+    n8nApiKey: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    projectName: z.ZodOptional<z.ZodString>;
+    projectIndex: z.ZodOptional<z.ZodNumber>;
+    listScope: z.ZodOptional<z.ZodEnum<["all", "local", "remote", "distant"]>>;
+    workflowId: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    skillsArgs: z.ZodOptional<z.ZodString>;
+    skillsArgv: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    validateFile: z.ZodOptional<z.ZodString>;
+    syncFolder: z.ZodOptional<z.ZodString>;
+    resolveMode: z.ZodOptional<z.ZodEnum<["keep-current", "keep-incoming"]>>;
+}, "strip", z.ZodTypeAny, {
+    action: "validate" | "verify" | "push" | "list" | "resolve" | "setup_check" | "init_auth" | "init_project" | "pull" | "skills" | "update_ai" | "skillsArgs" | "skillsArgv";
+    syncFolder?: string | undefined;
+    projectId?: string | undefined;
+    projectName?: string | undefined;
+    skillsArgs?: string | undefined;
+    skillsArgv?: string[] | undefined;
+    n8nHost?: string | undefined;
+    n8nApiKey?: string | undefined;
+    projectIndex?: number | undefined;
+    listScope?: "all" | "local" | "remote" | "distant" | undefined;
+    workflowId?: string | undefined;
+    filename?: string | undefined;
+    validateFile?: string | undefined;
+    resolveMode?: "keep-current" | "keep-incoming" | undefined;
+}, {
+    action: "validate" | "verify" | "push" | "list" | "resolve" | "setup_check" | "init_auth" | "init_project" | "pull" | "skills" | "update_ai" | "skillsArgs" | "skillsArgv";
+    syncFolder?: string | undefined;
+    projectId?: string | undefined;
+    projectName?: string | undefined;
+    skillsArgs?: string | undefined;
+    skillsArgv?: string[] | undefined;
+    n8nHost?: string | undefined;
+    n8nApiKey?: string | undefined;
+    projectIndex?: number | undefined;
+    listScope?: "all" | "local" | "remote" | "distant" | undefined;
+    workflowId?: string | undefined;
+    filename?: string | undefined;
+    validateFile?: string | undefined;
+    resolveMode?: "keep-current" | "keep-incoming" | undefined;
+}>, {
+    workspaceRoot: string;
+    next: string;
+    initialized: boolean;
+    configPath: string;
+    exitCode?: undefined;
+    timedOut?: undefined;
+    stdout?: undefined;
+    stderr?: undefined;
+    aiContextRefreshed?: undefined;
+    aiContextStdout?: undefined;
+    aiContextStderr?: undefined;
+} | {
+    exitCode: number;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+    next: string;
+    aiContextRefreshed?: undefined;
+    aiContextStdout?: undefined;
+    aiContextStderr?: undefined;
+} | {
+    exitCode: number;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+    next?: undefined;
+    aiContextRefreshed?: undefined;
+    aiContextStdout?: undefined;
+    aiContextStderr?: undefined;
+} | {
+    exitCode: number;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+    aiContextRefreshed: boolean;
+    aiContextStdout: string;
+    aiContextStderr: string;
+    next: string;
+}> & {
+    execute: (args: {
+        action: "validate" | "verify" | "push" | "list" | "resolve" | "setup_check" | "init_auth" | "init_project" | "pull" | "skills" | "update_ai" | "skillsArgs" | "skillsArgv";
+        syncFolder?: string | undefined;
+        projectId?: string | undefined;
+        projectName?: string | undefined;
+        skillsArgs?: string | undefined;
+        skillsArgv?: string[] | undefined;
+        n8nHost?: string | undefined;
+        n8nApiKey?: string | undefined;
+        projectIndex?: number | undefined;
+        listScope?: "all" | "local" | "remote" | "distant" | undefined;
+        workflowId?: string | undefined;
+        filename?: string | undefined;
+        validateFile?: string | undefined;
+        resolveMode?: "keep-current" | "keep-incoming" | undefined;
+    }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
+        workspaceRoot: string;
+        next: string;
+        initialized: boolean;
+        configPath: string;
+        exitCode?: undefined;
+        timedOut?: undefined;
+        stdout?: undefined;
+        stderr?: undefined;
+        aiContextRefreshed?: undefined;
+        aiContextStdout?: undefined;
+        aiContextStderr?: undefined;
+    } | {
+        exitCode: number;
+        timedOut: boolean;
+        stdout: string;
+        stderr: string;
+        next: string;
+        aiContextRefreshed?: undefined;
+        aiContextStdout?: undefined;
+        aiContextStderr?: undefined;
+    } | {
+        exitCode: number;
+        timedOut: boolean;
+        stdout: string;
+        stderr: string;
+        next?: undefined;
+        aiContextRefreshed?: undefined;
+        aiContextStdout?: undefined;
+        aiContextStderr?: undefined;
+    } | {
+        exitCode: number;
+        timedOut: boolean;
+        stdout: string;
+        stderr: string;
+        aiContextRefreshed: boolean;
+        aiContextStdout: string;
+        aiContextStderr: string;
+        next: string;
+    }>;
+};
+//# sourceMappingURL=n8nac.d.ts.map

package/dist/tools/n8nac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"n8nac.d.ts","sourceRoot":"","sources":["../../src/tools/n8nac.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAgC,KAAK,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAkNzF,wBAAgB,eAAe,CAAC,QAAQ,CAAC,EAAE,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAlBd,OAAO;gBAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAA3B,OAAO;oBAAc,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqO5E"}

package/dist/tools/n8nac.js

@@ -0,0 +1,349 @@
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
+import { tool } from 'ai';
+import { z } from 'zod';
+import { emitToolEvent, quoteShellArg } from './observer.js';
+import { relativeWorkspacePath, resolveWorkspacePath, truncateText, workspaceRoot } from './workspace-utils.js';
+const N8NAC_ACTIONS = [
+    'setup_check',
+    'init_auth',
+    'init_project',
+    'list',
+    'pull',
+    'push',
+    'verify',
+    'skills',
+    'validate',
+    'update_ai',
+    'resolve',
+    'skillsArgs',
+    'skillsArgv',
+];
+function normalizeN8nAcAction(action) {
+    if (action === 'skillsArgs' || action === 'skillsArgv') {
+        return 'skills';
+    }
+    return action;
+}
+function splitArgv(input) {
+    const args = [];
+    let current = '';
+    let quote = null;
+    let escaping = false;
+    for (const character of input) {
+        if (escaping) {
+            current += character;
+            escaping = false;
+            continue;
+        }
+        if (character === '\\' && quote !== '\'') {
+            escaping = true;
+            continue;
+        }
+        if (quote) {
+            if (character === quote) {
+                quote = null;
+            }
+            else {
+                current += character;
+            }
+            continue;
+        }
+        if (character === '"' || character === '\'') {
+            quote = character;
+            continue;
+        }
+        if (/\s/.test(character)) {
+            if (current) {
+                args.push(current);
+                current = '';
+            }
+            continue;
+        }
+        current += character;
+    }
+    if (escaping) {
+        current += '\\';
+    }
+    if (quote) {
+        return null;
+    }
+    if (current) {
+        args.push(current);
+    }
+    return args;
+}
+function runN8nac(args, cwd, env, onOutput) {
+    return new Promise((resolve) => {
+        const child = spawn('npx', ['--yes', 'n8nac', ...args], {
+            cwd,
+            env: { ...process.env, ...env },
+            stdio: 'pipe',
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let timedOut = false;
+        let killTimer;
+        const finish = (result) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            if (killTimer) {
+                clearTimeout(killTimer);
+            }
+            resolve(result);
+        };
+        child.stdout.on('data', (chunk) => {
+            const text = chunk.toString();
+            stdout += text;
+            void onOutput?.('stdout', text);
+        });
+        child.stderr.on('data', (chunk) => {
+            const text = chunk.toString();
+            stderr += text;
+            void onOutput?.('stderr', text);
+        });
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            killTimer = setTimeout(() => {
+                child.kill('SIGKILL');
+                finish({ stdout, stderr: stderr || 'Process timed out.', exitCode: 1, timedOut: true });
+            }, 2_000);
+        }, 120_000);
+        child.on('error', (error) => {
+            finish({ stdout, stderr: error.message || stderr, exitCode: 1, timedOut });
+        });
+        child.on('close', (exitCode) => {
+            finish({ stdout, stderr, exitCode: exitCode ?? 1, timedOut });
+        });
+    });
+}
+async function runObservedN8nac(observer, args, cwd, env) {
+    const command = ['npx', '--yes', 'n8nac', ...args].map(quoteShellArg).join(' ');
+    await emitToolEvent(observer, {
+        type: 'command-start',
+        toolName: 'n8nac',
+        command,
+        cwd: relativeWorkspacePath(cwd),
+    });
+    const result = await runN8nac(args, cwd, env, async (stream, chunk) => {
+        await emitToolEvent(observer, {
+            type: 'command-output',
+            toolName: 'n8nac',
+            stream,
+            chunk,
+        });
+    });
+    await emitToolEvent(observer, {
+        type: 'command-end',
+        toolName: 'n8nac',
+        exitCode: result.exitCode,
+        timedOut: result.timedOut,
+        message: result.exitCode === 0 ? 'Commande terminee.' : 'Commande en echec.',
+    });
+    return result;
+}
+function isWorkspaceInitialized() {
+    const configPath = resolveWorkspacePath('n8nac-config.json');
+    if (!fs.existsSync(configPath)) {
+        return { initialized: false, configPath: relativeWorkspacePath(configPath) };
+    }
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(raw);
+        return {
+            initialized: Boolean(config.projectId && config.projectName),
+            configPath: relativeWorkspacePath(configPath),
+        };
+    }
+    catch {
+        return { initialized: false, configPath: relativeWorkspacePath(configPath) };
+    }
+}
+export function createN8nAcTool(observer) {
+    return tool({
+        description: 'Run n8n-as-code workflow operations from the active workspace. For skills queries, use action="skills" with either skillsArgs as a single shell-like string or skillsArgv as an array of arguments.',
+        parameters: z.object({
+            action: z.enum(N8NAC_ACTIONS).describe('Primary n8nac action. Use skills for any n8nac skills subcommand; skillsArgs and skillsArgv are accepted as legacy aliases and normalize to skills.'),
+            n8nHost: z.string().optional().describe('n8n host URL for init_auth.'),
+            n8nApiKey: z.string().optional().describe('n8n API key for init_auth.'),
+            projectId: z.string().optional().describe('n8n project ID for init_project.'),
+            projectName: z.string().optional().describe('n8n project name for init_project.'),
+            projectIndex: z.number().int().min(1).optional().describe('1-based project selector for init_project.'),
+            listScope: z.enum(['all', 'local', 'remote', 'distant']).optional().describe('Workflow listing scope for list.'),
+            workflowId: z.string().optional().describe('Workflow ID for pull, verify, or resolve.'),
+            filename: z.string().optional().describe('Workflow filename including .workflow.ts for push.'),
+            skillsArgs: z.string().optional().describe('String form of n8nac skills arguments, for example search telegram.'),
+            skillsArgv: z.array(z.string()).optional().describe('Array form of n8nac skills arguments when values contain spaces.'),
+            validateFile: z.string().optional().describe('Local workflow file path for n8nac skills validate.'),
+            syncFolder: z.string().optional().describe('Sync folder to pass to init_project. Defaults to workflows.'),
+            resolveMode: z.enum(['keep-current', 'keep-incoming']).optional().describe('Conflict resolution mode for resolve.'),
+        }),
+        execute: async ({ action, n8nHost, n8nApiKey, projectId, projectName, projectIndex, listScope, workflowId, filename, skillsArgs, skillsArgv, validateFile, syncFolder, resolveMode, }) => {
+            action = normalizeN8nAcAction(action);
+            const cwd = workspaceRoot();
+            if (action === 'setup_check') {
+                const status = isWorkspaceInitialized();
+                return {
+                    ...status,
+                    workspaceRoot: relativeWorkspacePath(cwd),
+                    next: status.initialized
+                        ? 'Workspace is initialized. You can list, pull, edit, validate, push, and verify workflows.'
+                        : 'Workspace is not initialized. Ask for missing n8n credentials, then run init_auth followed by init_project.',
+                };
+            }
+            if (action === 'init_auth') {
+                if (!n8nHost || !n8nApiKey) {
+                    throw new Error('init_auth requires n8nHost and n8nApiKey');
+                }
+                const result = await runObservedN8nac(observer, ['init-auth', '--host', n8nHost, '--api-key', n8nApiKey], cwd);
+                return {
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stdout: truncateText(result.stdout),
+                    stderr: truncateText(result.stderr),
+                    next: result.exitCode === 0
+                        ? 'Credentials saved. Continue with init_project.'
+                        : 'Initialization auth failed. Inspect stderr and retry with corrected host or API key.',
+                };
+            }
+            if (action === 'init_project') {
+                const args = ['init-project', '--sync-folder', syncFolder || 'workflows'];
+                if (projectId) {
+                    args.push('--project-id', projectId);
+                }
+                else if (projectName) {
+                    args.push('--project-name', projectName);
+                }
+                else {
+                    args.push('--project-index', String(projectIndex ?? 1));
+                }
+                const result = await runObservedN8nac(observer, args, cwd);
+                if (result.exitCode !== 0) {
+                    return {
+                        exitCode: result.exitCode,
+                        timedOut: result.timedOut,
+                        stdout: truncateText(result.stdout),
+                        stderr: truncateText(result.stderr),
+                    };
+                }
+                const refresh = await runObservedN8nac(observer, ['update-ai'], cwd);
+                return {
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stdout: truncateText(result.stdout),
+                    stderr: truncateText(result.stderr),
+                    aiContextRefreshed: refresh.exitCode === 0,
+                    aiContextStdout: truncateText(refresh.stdout),
+                    aiContextStderr: truncateText(refresh.stderr),
+                    next: refresh.exitCode === 0
+                        ? 'Workspace initialized and AGENTS.md refreshed.'
+                        : 'Workspace initialized, but AGENTS.md refresh failed. Inspect aiContextStderr.',
+                };
+            }
+            if (action === 'list') {
+                const args = ['list'];
+                if (listScope && listScope !== 'all') {
+                    args.push(`--${listScope}`);
+                }
+                const result = await runObservedN8nac(observer, args, cwd);
+                return {
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stdout: truncateText(result.stdout),
+                    stderr: truncateText(result.stderr),
+                };
+            }
+            if (action === 'pull') {
+                if (!workflowId) {
+                    throw new Error('pull requires workflowId');
+                }
+                const result = await runObservedN8nac(observer, ['pull', workflowId], cwd);
+                return {
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stdout: truncateText(result.stdout),
+                    stderr: truncateText(result.stderr),
+                };
+            }
+            if (action === 'push') {
+                if (!filename) {
+                    throw new Error('push requires filename including .workflow.ts');
+                }
+                const result = await runObservedN8nac(observer, ['push', filename, '--verify'], cwd);
+                return {
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stdout: truncateText(result.stdout),
+                    stderr: truncateText(result.stderr),
+                };
+            }
+            if (action === 'verify') {
+                if (!workflowId) {
+                    throw new Error('verify requires workflowId');
+                }
+                const result = await runObservedN8nac(observer, ['verify', workflowId], cwd);
+                return {
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stdout: truncateText(result.stdout),
+                    stderr: truncateText(result.stderr),
+                };
+            }
+            if (action === 'skills') {
+                const argv = Array.isArray(skillsArgv) && skillsArgv.length > 0
+                    ? skillsArgv
+                    : skillsArgs
+                        ? splitArgv(skillsArgs)
+                        : null;
+                if (!argv) {
+                    throw new Error('skills requires skillsArgv or a valid skillsArgs string');
+                }
+                const result = await runObservedN8nac(observer, ['skills', ...argv], cwd);
+                return {
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stdout: truncateText(result.stdout),
+                    stderr: truncateText(result.stderr),
+                };
+            }
+            if (action === 'validate') {
+                if (!validateFile) {
+                    throw new Error('validate requires validateFile');
+                }
+                const filePath = relativeWorkspacePath(resolveWorkspacePath(validateFile));
+                const result = await runObservedN8nac(observer, ['skills', 'validate', filePath], cwd);
+                return {
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stdout: truncateText(result.stdout),
+                    stderr: truncateText(result.stderr),
+                };
+            }
+            if (action === 'update_ai') {
+                const result = await runObservedN8nac(observer, ['update-ai'], cwd);
+                return {
+                    exitCode: result.exitCode,
+                    timedOut: result.timedOut,
+                    stdout: truncateText(result.stdout),
+                    stderr: truncateText(result.stderr),
+                };
+            }
+            if (!workflowId || !resolveMode) {
+                throw new Error('resolve requires workflowId and resolveMode');
+            }
+            const result = await runObservedN8nac(observer, ['resolve', workflowId, '--mode', resolveMode], cwd);
+            return {
+                exitCode: result.exitCode,
+                timedOut: result.timedOut,
+                stdout: truncateText(result.stdout),
+                stderr: truncateText(result.stderr),
+            };
+        },
+    });
+}
+//# sourceMappingURL=n8nac.js.map