@kairos-sdk/core 0.2.1 → 0.3.1

package/dist/{chunk-QQJDLS5A.js → chunk-RYGYNOR6.js}

@@ -1,30 +1,3 @@
-// src/utils/uuid.ts
-function generateUUID() {
-  return crypto.randomUUID();
-}
-
-// src/library/null-library.ts
-var NullLibrary = class {
-  async initialize() {
-  }
-  async search(_description, _options) {
-    return [];
-  }
-  async save(_workflow, _metadata) {
-    return generateUUID();
-  }
-  async recordDeployment(_id) {
-  }
-  async recordOutcome(_id, _outcome) {
-  }
-  async get(_id) {
-    return null;
-  }
-  async list(_filters) {
-    return [];
-  }
-};
-
 // src/errors/base.ts
 var KairosError = class extends Error {
   constructor(message, cause) {
@@ -220,6 +193,14 @@ var N8nApiClient = class {
     const remaining = (current.tags ?? []).filter((t) => !tagIds.includes(t.id)).map((t) => ({ id: t.id }));
     await this.request("PUT", `/workflows/${workflowId}/tags`, remaining);
   }
+  async getNodeTypes() {
+    try {
+      const response = await this.request("GET", "/node-types");
+      return response.data ?? response;
+    } catch {
+      return [];
+    }
+  }
   mapExecution(e) {
     return {
       id: e.id,
@@ -267,78 +248,6 @@ var N8nFieldStripper = class {
   }
 };
 
-// src/errors/guard-error.ts
-var GuardError = class extends KairosError {
-  constructor(message) {
-    super(message);
-    this.name = "GuardError";
-  }
-};
-
-// src/providers/n8n/provider.ts
-var N8nProvider = class {
-  constructor(client, stripper) {
-    this.client = client;
-    this.stripper = stripper;
-  }
-  client;
-  stripper;
-  platform = "n8n";
-  async deploy(workflow) {
-    const stripped = this.stripper.stripForCreate(workflow);
-    const response = await this.client.createWorkflow(stripped);
-    return { workflowId: response.id, name: response.name };
-  }
-  async update(id, workflow) {
-    const stripped = this.stripper.stripForUpdate(workflow);
-    const response = await this.client.updateWorkflow(id, stripped);
-    return { workflowId: response.id, name: response.name };
-  }
-  async get(id) {
-    const response = await this.client.getWorkflow(id);
-    return {
-      name: response.name,
-      nodes: response.nodes,
-      connections: response.connections,
-      ...response.settings !== void 0 ? { settings: response.settings } : {},
-      ...response.tags !== void 0 ? { tags: response.tags } : {}
-    };
-  }
-  async list() {
-    return this.client.listWorkflows();
-  }
-  async activate(id) {
-    await this.client.activateWorkflow(id);
-  }
-  async deactivate(id) {
-    await this.client.deactivateWorkflow(id);
-  }
-  async delete(id, options) {
-    if (options.confirm !== true) {
-      throw new GuardError("delete() requires { confirm: true } to prevent accidental deletion");
-    }
-    await this.client.deleteWorkflow(id);
-  }
-  async executions(workflowId, filter) {
-    return this.client.getExecutions(workflowId, filter);
-  }
-  async execution(id) {
-    return this.client.getExecution(id);
-  }
-  async listTags() {
-    return this.client.listTags();
-  }
-  async createTag(name) {
-    return this.client.createTag(name);
-  }
-  async tag(workflowId, tagIds) {
-    await this.client.tagWorkflow(workflowId, tagIds);
-  }
-  async untag(workflowId, tagIds) {
-    await this.client.untagWorkflow(workflowId, tagIds);
-  }
-};
-
 // src/validation/registry.ts
 var DEFAULT_REGISTRY = [
   // Trigger nodes
@@ -843,170 +752,6 @@ var N8nValidator = class {
   }
 };
 
-// src/errors/generation-error.ts
-var GenerationError = class extends KairosError {
-  constructor(message, cause) {
-    super(message, cause);
-    this.name = "GenerationError";
-  }
-};
-
-// src/errors/response-parse-error.ts
-var ResponseParseError = class extends KairosError {
-  constructor(message, cause) {
-    super(message, cause);
-    this.name = "ResponseParseError";
-  }
-};
-
-// src/errors/validation-error.ts
-var ValidationError = class extends KairosError {
-  constructor(message, issues) {
-    super(message);
-    this.issues = issues;
-    this.name = "ValidationError";
-  }
-  issues;
-};
-
-// src/telemetry/collector.ts
-import { appendFile, mkdir } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-
-// src/telemetry/types.ts
-var TELEMETRY_SCHEMA_VERSION = 2;
-
-// src/telemetry/collector.ts
-var TelemetryCollector = class {
-  dir;
-  sessionId;
-  dirReady = null;
-  constructor(dir) {
-    this.dir = dir ?? join(homedir(), ".kairos", "telemetry");
-    this.sessionId = generateUUID();
-  }
-  async emit(eventType, data) {
-    const event = {
-      schemaVersion: TELEMETRY_SCHEMA_VERSION,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      sessionId: this.sessionId,
-      eventType,
-      data
-    };
-    if (!this.dirReady) {
-      this.dirReady = mkdir(this.dir, { recursive: true }).then(() => {
-      });
-    }
-    await this.dirReady;
-    const filename = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) + ".jsonl";
-    const filepath = join(this.dir, filename);
-    await appendFile(filepath, JSON.stringify(event) + "\n", "utf-8");
-  }
-};
-
-// src/telemetry/reader.ts
-import { readFile, readdir } from "fs/promises";
-import { join as join2 } from "path";
-import { homedir as homedir2 } from "os";
-var TelemetryReader = class {
-  dir;
-  cache = null;
-  cacheTime = 0;
-  constructor(dir) {
-    this.dir = dir ?? join2(homedir2(), ".kairos", "telemetry");
-  }
-  async getFailureRates(days = 30) {
-    const now = Date.now();
-    if (this.cache && now - this.cacheTime < 5 * 60 * 1e3) {
-      return this.cache;
-    }
-    const events = await this.readRecentEvents(days);
-    const buildSessions = new Set(
-      events.filter((e) => e.eventType === "build_complete" && !e.data.dryRun).map((e) => e.sessionId)
-    );
-    if (buildSessions.size === 0) return [];
-    const ruleSessions = /* @__PURE__ */ new Map();
-    for (const event of events) {
-      if (event.eventType !== "generation_attempt") continue;
-      if (!buildSessions.has(event.sessionId)) continue;
-      const data = event.data;
-      if (data.validationPassed || !data.issues) continue;
-      for (const issue of data.issues) {
-        const entry = ruleSessions.get(issue.rule) ?? { sessions: /* @__PURE__ */ new Set(), messages: /* @__PURE__ */ new Map() };
-        entry.sessions.add(event.sessionId);
-        entry.messages.set(issue.message, (entry.messages.get(issue.message) ?? 0) + 1);
-        ruleSessions.set(issue.rule, entry);
-      }
-    }
-    const rates = [];
-    for (const [rule, entry] of ruleSessions) {
-      let topMessage = "";
-      let topCount = 0;
-      for (const [msg, count] of entry.messages) {
-        if (count > topCount) {
-          topMessage = msg;
-          topCount = count;
-        }
-      }
-      rates.push({
-        rule,
-        failureCount: entry.sessions.size,
-        totalBuilds: buildSessions.size,
-        rate: entry.sessions.size / buildSessions.size,
-        commonMessage: topMessage
-      });
-    }
-    rates.sort((a, b) => b.rate - a.rate);
-    this.cache = rates;
-    this.cacheTime = now;
-    return rates;
-  }
-  async readRecentEvents(days) {
-    let files;
-    try {
-      files = await readdir(this.dir);
-    } catch {
-      return [];
-    }
-    const cutoff = /* @__PURE__ */ new Date();
-    cutoff.setDate(cutoff.getDate() - days);
-    const cutoffStr = cutoff.toISOString().slice(0, 10);
-    const datePattern = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
-    const recentFiles = files.filter((f) => datePattern.test(f) && f >= cutoffStr).sort();
-    const events = [];
-    for (const file of recentFiles) {
-      try {
-        const content = await readFile(join2(this.dir, file), "utf-8");
-        for (const line of content.split("\n")) {
-          if (!line.trim()) continue;
-          try {
-            events.push(JSON.parse(line));
-          } catch {
-          }
-        }
-      } catch {
-      }
-    }
-    return events;
-  }
-};
-
-// src/utils/logger.ts
-var nullLogger = {
-  debug() {
-  },
-  info() {
-  },
-  warn() {
-  },
-  error() {
-  }
-};
-
-// src/client.ts
-import Anthropic from "@anthropic-ai/sdk";
-
 // src/generation/prompts/v1.ts
 var SYSTEM_PROMPT_V1 = `You are a workflow generation engine for n8n. Your only output is a generate_workflow tool call containing valid n8n workflow JSON. You never respond with prose, explanations, or markdown. If you cannot fulfill the request, set the error field in the tool call.
 
@@ -1223,9 +968,9 @@ var RULE_REMEDIES = {
   22: "Ensure all required parameters are set for each node type (e.g. webhook needs httpMethod and path)"
 };
 var PromptBuilder = class {
-  build(request, matches, globalFailureRates = []) {
+  build(request, matches, globalFailureRates = [], dynamicCatalog) {
     const mode = this.resolveMode(matches);
-    const system = this.buildSystem(matches, mode, globalFailureRates);
+    const system = this.buildSystem(matches, mode, globalFailureRates, dynamicCatalog);
     const userMessage = this.buildUserMessage(request, matches, mode);
     return { system, userMessage, mode, matches };
   }
@@ -1244,11 +989,18 @@ Fix ALL of the above issues in your new response. Do not repeat any of these mis
     if (!top) return "scratch";
     return scoreToMode(top.score);
   }
-  buildSystem(matches, mode, globalFailureRates = []) {
+  buildSystem(matches, mode, globalFailureRates = [], dynamicCatalog) {
+    let basePrompt = SYSTEM_PROMPT_V1;
+    if (dynamicCatalog) {
+      basePrompt = basePrompt.replace(
+        /## NODE CATALOG — exact type strings and safe typeVersions[\s\S]*?(?=## PRE-DELIVERY SELF-CHECK)/,
+        dynamicCatalog + "\n\n"
+      );
+    }
     const blocks = [
       {
         type: "text",
-        text: SYSTEM_PROMPT_V1,
+        text: basePrompt,
         cache_control: { type: "ephemeral" }
       }
     ];
@@ -1332,454 +1084,102 @@ Workflow name: "${request.name}"` : "";
   }
 };
 
-// src/generation/designer.ts
-var MAX_ATTEMPTS = 3;
-var BASE_TEMPERATURE = 0.2;
-var FINAL_TEMPERATURE = 0.1;
-var GENERATE_WORKFLOW_TOOL = {
-  name: "generate_workflow",
-  description: "Generate a valid n8n workflow JSON object",
-  input_schema: {
-    type: "object",
-    properties: {
-      workflow: {
-        type: "object",
-        description: "The complete n8n workflow object",
-        properties: {
-          name: { type: "string" },
-          nodes: { type: "array" },
-          connections: { type: "object" },
-          settings: { type: "object" }
-        },
-        required: ["name", "nodes", "connections"]
-      },
-      credentialsNeeded: {
-        type: "array",
-        description: "List of credentials the user must configure before activating",
-        items: {
-          type: "object",
-          properties: {
-            service: { type: "string" },
-            credentialType: { type: "string" },
-            description: { type: "string" }
-          },
-          required: ["service", "credentialType", "description"]
-        }
-      },
-      error: {
-        type: "string",
-        description: "Set this if the request cannot be fulfilled \u2014 explain why"
-      }
-    },
-    required: []
-  }
-};
-var WorkflowDesigner = class {
-  constructor(anthropic, model, logger) {
-    this.anthropic = anthropic;
-    this.model = model;
-    this.logger = logger;
-    this.validator = new N8nValidator();
-    this.promptBuilder = new PromptBuilder();
+// src/telemetry/reader.ts
+import { readFile, readdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var TelemetryReader = class {
+  dir;
+  cache = null;
+  cacheTime = 0;
+  constructor(dir) {
+    this.dir = dir ?? join(homedir(), ".kairos", "telemetry");
   }
-  anthropic;
-  model;
-  logger;
-  validator;
-  promptBuilder;
-  async design(request, matches, globalFailureRates = []) {
-    const attemptMetadata = [];
-    let lastErrors = [];
-    let attempts = 0;
-    const built = this.promptBuilder.build(request, matches, globalFailureRates);
-    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-      attempts = attempt;
-      const temperature = attempt === MAX_ATTEMPTS ? FINAL_TEMPERATURE : BASE_TEMPERATURE;
-      let userMessage;
-      if (attempt === 1) {
-        userMessage = built.userMessage;
-        this.logger.debug("WorkflowDesigner: attempt 1", { description: request.description });
-      } else {
-        const issueLines = lastErrors.map(
-          (i) => `- [Rule ${i.rule}] ${i.message}${i.nodeId ? ` (node: ${i.nodeId})` : ""}`
-        );
-        userMessage = this.promptBuilder.buildCorrectionMessage(request, matches, issueLines, attempt - 1);
-        this.logger.debug(`WorkflowDesigner: correction attempt ${attempt}`, { issueCount: lastErrors.length });
-      }
-      const start = Date.now();
-      const message = await this.callClaude(built.system, userMessage, temperature);
-      const durationMs = Date.now() - start;
-      const parsed = this.extractToolUse(message);
-      if (parsed.error) {
-        throw new GenerationError(`Claude declined to generate workflow: ${parsed.error}`);
+  async getFailureRates(days = 30) {
+    const now = Date.now();
+    if (this.cache && now - this.cacheTime < 5 * 60 * 1e3) {
+      return this.cache;
+    }
+    const events = await this.readRecentEvents(days);
+    const buildSessions = new Set(
+      events.filter((e) => e.eventType === "build_complete" && !e.data.dryRun).map((e) => e.sessionId)
+    );
+    if (buildSessions.size === 0) return [];
+    const ruleSessions = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      if (event.eventType !== "generation_attempt") continue;
+      if (!buildSessions.has(event.sessionId)) continue;
+      const data = event.data;
+      if (data.validationPassed || !data.issues) continue;
+      for (const issue of data.issues) {
+        const entry = ruleSessions.get(issue.rule) ?? { sessions: /* @__PURE__ */ new Set(), messages: /* @__PURE__ */ new Map() };
+        entry.sessions.add(event.sessionId);
+        entry.messages.set(issue.message, (entry.messages.get(issue.message) ?? 0) + 1);
+        ruleSessions.set(issue.rule, entry);
       }
-      const validation = this.validator.validate(parsed.workflow);
-      const errors = validation.issues.filter((i) => i.severity === "error");
-      attemptMetadata.push({
-        attempt,
-        temperature,
-        durationMs,
-        tokensInput: message.usage.input_tokens,
-        tokensOutput: message.usage.output_tokens,
-        validationPassed: validation.valid,
-        issues: validation.issues
-      });
-      if (validation.valid) {
-        return { workflow: parsed.workflow, credentialsNeeded: parsed.credentialsNeeded, attempts, attemptMetadata };
+    }
+    const rates = [];
+    for (const [rule, entry] of ruleSessions) {
+      let topMessage = "";
+      let topCount = 0;
+      for (const [msg, count] of entry.messages) {
+        if (count > topCount) {
+          topMessage = msg;
+          topCount = count;
+        }
       }
-      lastErrors = errors;
-      this.logger.warn(`WorkflowDesigner: validation failed on attempt ${attempt}`, {
-        errorCount: errors.length
+      rates.push({
+        rule,
+        failureCount: entry.sessions.size,
+        totalBuilds: buildSessions.size,
+        rate: entry.sessions.size / buildSessions.size,
+        commonMessage: topMessage
       });
     }
-    const finalIssues = attemptMetadata.at(-1)?.issues ?? lastErrors;
-    throw new ValidationError(
-      `Workflow failed validation after ${MAX_ATTEMPTS} attempts`,
-      finalIssues
-    );
+    rates.sort((a, b) => b.rate - a.rate);
+    this.cache = rates;
+    this.cacheTime = now;
+    return rates;
   }
-  async callClaude(system, userMessage, temperature) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), 12e4);
+  async readRecentEvents(days) {
+    let files;
     try {
-      return await this.anthropic.messages.create(
-        {
-          model: this.model,
-          max_tokens: 8192,
-          temperature,
-          system: system.map((b) => ({ type: b.type, text: b.text, ...b.cache_control ? { cache_control: b.cache_control } : {} })),
-          messages: [{ role: "user", content: userMessage }],
-          tools: [GENERATE_WORKFLOW_TOOL],
-          tool_choice: { type: "tool", name: "generate_workflow" }
-        },
-        { signal: controller.signal }
-      );
-    } catch (err) {
-      const detail = err instanceof Error ? err.message : String(err);
-      throw new GenerationError(`Anthropic API call failed: ${detail}`, err);
-    } finally {
-      clearTimeout(timer);
-    }
-  }
-  extractToolUse(message) {
-    const toolUseBlock = message.content.find(
-      (block) => block.type === "tool_use"
-    );
-    if (!toolUseBlock) {
-      throw new ResponseParseError(
-        "Claude response contained no tool_use block \u2014 forced tool_choice failed unexpectedly"
-      );
-    }
-    const input = toolUseBlock.input;
-    if (typeof input["error"] === "string") {
-      return {
-        workflow: { name: "", nodes: [], connections: {} },
-        credentialsNeeded: [],
-        error: input["error"]
-      };
-    }
-    if (!input["workflow"] || typeof input["workflow"] !== "object") {
-      throw new ResponseParseError("generate_workflow tool call missing workflow field");
+      files = await readdir(this.dir);
+    } catch {
+      return [];
     }
-    const workflow = input["workflow"];
-    const credentialsNeeded = input["credentialsNeeded"] ?? [];
-    return { workflow, credentialsNeeded };
-  }
-};
-
-// src/client.ts
-var DEFAULT_MODEL = "claude-sonnet-4-6";
-var Kairos = class {
-  provider;
-  designer;
-  validator;
-  library;
-  logger;
-  telemetry;
-  telemetryReader;
-  model;
-  saveQueue = Promise.resolve(null);
-  constructor(options) {
-    const logger = options.logger ?? nullLogger;
-    this.model = options.model ?? DEFAULT_MODEL;
-    if (options.n8nBaseUrl && options.n8nApiKey) {
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setDate(cutoff.getDate() - days);
+    const cutoffStr = cutoff.toISOString().slice(0, 10);
+    const datePattern = /^\d{4}-\d{2}-\d{2}\.jsonl$/;
+    const recentFiles = files.filter((f) => datePattern.test(f) && f >= cutoffStr).sort();
+    const events = [];
+    for (const file of recentFiles) {
       try {
-        new URL(options.n8nBaseUrl);
+        const content = await readFile(join(this.dir, file), "utf-8");
+        for (const line of content.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            events.push(JSON.parse(line));
+          } catch {
+          }
+        }
       } catch {
-        throw new GuardError(`Invalid n8nBaseUrl: "${options.n8nBaseUrl}" \u2014 must be a valid URL`);
-      }
-      const apiClient = new N8nApiClient(options.n8nBaseUrl, options.n8nApiKey, logger);
-      const stripper = new N8nFieldStripper();
-      this.provider = new N8nProvider(apiClient, stripper);
-    } else {
-      this.provider = null;
-    }
-    const anthropic = new Anthropic({ apiKey: options.anthropicApiKey });
-    this.designer = new WorkflowDesigner(anthropic, this.model, logger);
-    this.validator = new N8nValidator();
-    this.library = options.library ?? new NullLibrary();
-    this.logger = logger;
-    if (options.telemetry === true) {
-      this.telemetry = new TelemetryCollector();
-      this.telemetryReader = new TelemetryReader();
-    } else if (typeof options.telemetry === "string") {
-      this.telemetry = new TelemetryCollector(options.telemetry);
-      this.telemetryReader = new TelemetryReader(options.telemetry);
-    } else {
-      this.telemetry = null;
-      this.telemetryReader = null;
-    }
-  }
-  requireProvider() {
-    if (!this.provider) {
-      throw new GuardError("n8nBaseUrl and n8nApiKey are required for this operation \u2014 set them in the Kairos constructor, or use { dryRun: true } for generation-only mode");
-    }
-    return this.provider;
-  }
-  validateDescription(description) {
-    if (!description || description.trim().length === 0) {
-      throw new GuardError("Description is required and must be non-empty");
-    }
-  }
-  async build(description, options) {
-    this.validateDescription(description);
-    this.logger.info("Kairos.build", { description, dryRun: options?.dryRun });
-    const buildStart = Date.now();
-    await this.telemetry?.emit("build_start", {
-      description,
-      model: this.model,
-      dryRun: options?.dryRun ?? false
-    });
-    await this.library.initialize();
-    const matches = await this.library.search(description);
-    if (matches.length > 0) {
-      const top = matches[0];
-      this.logger.info(`Library: ${matches.length} match(es), top="${top.workflow.description.slice(0, 50)}" score=${top.score.toFixed(2)} mode=${top.mode}`);
-    } else {
-      this.logger.info("Library: no matches (scratch mode)");
-    }
-    const globalFailureRates = await this.telemetryReader?.getFailureRates() ?? [];
-    if (globalFailureRates.length > 0) {
-      const highFreq = globalFailureRates.filter((r) => r.rate >= 0.15);
-      if (highFreq.length > 0) {
-        this.logger.info(`Telemetry: ${highFreq.length} high-frequency failure rule(s) will be warned about`);
       }
     }
-    const designResult = await this.designer.design(
-      { description, ...options?.name ? { name: options.name } : {} },
-      matches,
-      globalFailureRates
-    );
-    await this.emitAttemptTelemetry(description, designResult);
-    const workflow = options?.name ? { ...designResult.workflow, name: options.name } : designResult.workflow;
-    this.saveToLibrary(workflow, description, designResult, matches);
-    if (options?.dryRun) {
-      const totalTokensInput2 = designResult.attemptMetadata.reduce((s, m) => s + m.tokensInput, 0);
-      const totalTokensOutput2 = designResult.attemptMetadata.reduce((s, m) => s + m.tokensOutput, 0);
-      await this.telemetry?.emit("build_complete", {
-        description,
-        success: true,
-        totalAttempts: designResult.attempts,
-        totalDurationMs: Date.now() - buildStart,
-        totalTokensInput: totalTokensInput2,
-        totalTokensOutput: totalTokensOutput2,
-        workflowName: workflow.name,
-        workflowId: null,
-        dryRun: true,
-        credentialsNeeded: designResult.credentialsNeeded.length
-      });
-      return {
-        workflowId: null,
-        name: workflow.name,
-        workflow,
-        credentialsNeeded: designResult.credentialsNeeded,
-        activationRequired: true,
-        generationAttempts: designResult.attempts,
-        dryRun: true
-      };
-    }
-    const provider = this.requireProvider();
-    const deployed = await provider.deploy(workflow);
-    this.recordDeploy();
-    if (options?.activate) {
-      await provider.activate(deployed.workflowId);
-    }
-    const totalTokensInput = designResult.attemptMetadata.reduce((s, m) => s + m.tokensInput, 0);
-    const totalTokensOutput = designResult.attemptMetadata.reduce((s, m) => s + m.tokensOutput, 0);
-    await this.telemetry?.emit("build_complete", {
-      description,
-      success: true,
-      totalAttempts: designResult.attempts,
-      totalDurationMs: Date.now() - buildStart,
-      totalTokensInput,
-      totalTokensOutput,
-      workflowName: deployed.name,
-      workflowId: deployed.workflowId,
-      dryRun: false,
-      credentialsNeeded: designResult.credentialsNeeded.length
-    });
-    return {
-      workflowId: deployed.workflowId,
-      name: deployed.name,
-      workflow,
-      credentialsNeeded: designResult.credentialsNeeded,
-      activationRequired: !options?.activate,
-      generationAttempts: designResult.attempts,
-      dryRun: false
-    };
-  }
-  async replace(id, description) {
-    this.validateDescription(description);
-    this.logger.info("Kairos.update", { id, description });
-    const buildStart = Date.now();
-    await this.telemetry?.emit("build_start", {
-      description,
-      model: this.model,
-      dryRun: false
-    });
-    await this.library.initialize();
-    const matches = await this.library.search(description);
-    const globalFailureRates = await this.telemetryReader?.getFailureRates() ?? [];
-    const designResult = await this.designer.design({ description }, matches, globalFailureRates);
-    await this.emitAttemptTelemetry(description, designResult);
-    const provider = this.requireProvider();
-    const deployed = await provider.update(id, designResult.workflow);
-    this.saveToLibrary(designResult.workflow, description, designResult, matches);
-    this.recordDeploy();
-    const totalTokensInput = designResult.attemptMetadata.reduce((s, m) => s + m.tokensInput, 0);
-    const totalTokensOutput = designResult.attemptMetadata.reduce((s, m) => s + m.tokensOutput, 0);
-    await this.telemetry?.emit("build_complete", {
-      description,
-      success: true,
-      totalAttempts: designResult.attempts,
-      totalDurationMs: Date.now() - buildStart,
-      totalTokensInput,
-      totalTokensOutput,
-      workflowName: deployed.name,
-      workflowId: deployed.workflowId,
-      dryRun: false,
-      credentialsNeeded: designResult.credentialsNeeded.length
-    });
-    return {
-      workflowId: deployed.workflowId,
-      name: deployed.name,
-      workflow: designResult.workflow,
-      credentialsNeeded: designResult.credentialsNeeded,
-      activationRequired: true,
-      generationAttempts: designResult.attempts,
-      dryRun: false
-    };
-  }
-  async drain() {
-    await this.saveQueue.catch(() => {
-    });
-  }
-  async emitAttemptTelemetry(description, designResult) {
-    for (const meta of designResult.attemptMetadata) {
-      await this.telemetry?.emit("generation_attempt", {
-        description,
-        attempt: meta.attempt,
-        temperature: meta.temperature,
-        durationMs: meta.durationMs,
-        tokensInput: meta.tokensInput,
-        tokensOutput: meta.tokensOutput,
-        validationPassed: meta.validationPassed,
-        issueCount: meta.issues.length,
-        issues: meta.issues.map((i) => ({ rule: i.rule, message: i.message }))
-      });
-    }
-  }
-  recordDeploy() {
-    this.saveQueue = this.saveQueue.then(async (savedId) => {
-      if (savedId) {
-        await this.library.recordDeployment(savedId);
-      }
-      return savedId;
-    }).catch((err) => {
-      this.logger.warn("Failed to record deployment (non-fatal)", { err: String(err) });
-      return null;
-    });
-  }
-  saveToLibrary(workflow, description, designResult, matches) {
-    const failedAttempts = designResult.attemptMetadata.filter((m) => !m.validationPassed);
-    const failurePatterns = failedAttempts.flatMap(
-      (m) => m.issues.map((i) => ({ rule: i.rule, message: i.message }))
-    );
-    const topMatch = matches[0];
-    const generationMode = topMatch ? scoreToMode(topMatch.score) : "scratch";
-    const autoTags = Array.from(new Set(
-      workflow.nodes.flatMap((n) => {
-        const bare = n.type.split(".").pop() ?? "";
-        const tags = [bare];
-        if (n.type.includes("Trigger") || n.type.includes("trigger")) tags.push(`trigger:${bare}`);
-        if (n.type.includes("langchain")) tags.push("ai");
-        return tags;
-      })
-    ));
-    const metadata = {
-      description,
-      generationMode,
-      generationAttempts: designResult.attempts
-    };
-    if (autoTags.length > 0) metadata.tags = autoTags;
-    if (failurePatterns.length > 0) metadata.failurePatterns = failurePatterns;
-    if (matches.length > 0) metadata.sourceWorkflowIds = matches.map((m) => m.workflow.id);
-    if (topMatch) metadata.topMatchScore = topMatch.score;
-    if (designResult.credentialsNeeded.length > 0) metadata.credentialsNeeded = designResult.credentialsNeeded;
-    const firstTryPass = designResult.attemptMetadata.length > 0 && designResult.attemptMetadata[0].validationPassed;
-    const failedRules = Array.from(new Set(
-      designResult.attemptMetadata.filter((m) => !m.validationPassed).flatMap((m) => m.issues.map((i) => i.rule))
-    ));
-    this.saveQueue = this.saveQueue.then(async () => {
-      const savedId = await this.library.save(workflow, metadata);
-      for (const match of matches) {
-        if (match.mode === "direct" || match.mode === "reference") {
-          await this.library.recordOutcome(match.workflow.id, {
-            attempts: designResult.attempts,
-            firstTryPass,
-            failedRules,
-            mode: match.mode
-          });
-        }
-      }
-      return savedId;
-    }).catch((err) => {
-      this.logger.warn("Failed to save workflow to library (non-fatal)", { err: String(err) });
-      return null;
-    });
-  }
-  async get(id) {
-    return this.requireProvider().get(id);
-  }
-  async list() {
-    return this.requireProvider().list();
-  }
-  async activate(id) {
-    await this.requireProvider().activate(id);
-  }
-  async deactivate(id) {
-    await this.requireProvider().deactivate(id);
-  }
-  async delete(id, options) {
-    await this.requireProvider().delete(id, options);
-  }
-  async executions(workflowId, filter) {
-    return this.requireProvider().executions(workflowId, filter);
-  }
-  async execution(id) {
-    return this.requireProvider().execution(id);
-  }
-  async listTags() {
-    return this.requireProvider().listTags();
-  }
-  async createTag(name) {
-    return this.requireProvider().createTag(name);
-  }
-  async tag(workflowId, tagIds) {
-    await this.requireProvider().tag(workflowId, tagIds);
+    return events;
   }
-  async untag(workflowId, tagIds) {
-    await this.requireProvider().untag(workflowId, tagIds);
+};
+
+// src/utils/logger.ts
+var nullLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
   }
 };
 
@@ -1999,9 +1399,16 @@ function rerank(candidates, clusters) {
 }
 
 // src/library/file-library.ts
-import { readFile as readFile2, writeFile, rename, mkdir as mkdir2 } from "fs/promises";
-import { join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+import { readFile as readFile2, writeFile, rename, mkdir } from "fs/promises";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/utils/uuid.ts
+function generateUUID() {
+  return crypto.randomUUID();
+}
+
+// src/library/file-library.ts
 function tokenize(text) {
   return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 2);
 }
@@ -2020,7 +1427,7 @@ var FileLibrary = class {
   initPromise = null;
   writeQueue = Promise.resolve();
   constructor(dir) {
-    this.dir = dir ?? join3(homedir3(), ".kairos", "library");
+    this.dir = dir ?? join2(homedir2(), ".kairos", "library");
   }
   async initialize() {
     if (!this.initPromise) {
@@ -2029,8 +1436,8 @@ var FileLibrary = class {
     return this.initPromise;
   }
   async doInitialize() {
-    await mkdir2(this.dir, { recursive: true });
-    const indexPath = join3(this.dir, "index.json");
+    await mkdir(this.dir, { recursive: true });
+    const indexPath = join2(this.dir, "index.json");
     try {
       const raw = await readFile2(indexPath, "utf-8");
       const parsed = JSON.parse(raw);
@@ -2162,7 +1569,7 @@ var FileLibrary = class {
   }
   persist() {
     this.writeQueue = this.writeQueue.then(async () => {
-      const indexPath = join3(this.dir, "index.json");
+      const indexPath = join2(this.dir, "index.json");
       const tmpPath = `${indexPath}.tmp`;
       await writeFile(tmpPath, JSON.stringify(this.workflows, null, 2), "utf-8");
       await rename(tmpPath, indexPath);
@@ -2171,206 +1578,25 @@ var FileLibrary = class {
   }
 };
 
-// src/templates/safety.ts
-var BLOCKED_NODE_TYPES = /* @__PURE__ */ new Set([
-  "n8n-nodes-base.code",
-  "n8n-nodes-base.executeCommand",
-  "n8n-nodes-base.ssh"
-]);
-var REVIEW_NODE_TYPES = /* @__PURE__ */ new Set([
-  "n8n-nodes-base.httpRequest"
-]);
-var SECRET_PATTERNS = [
-  /sk-[a-zA-Z0-9]{20,}/,
-  /ghp_[a-zA-Z0-9]{36}/,
-  /xoxb-[0-9]+-[0-9]+-[a-zA-Z0-9]+/,
-  /AIza[a-zA-Z0-9_-]{35}/,
-  /AKIA[A-Z0-9]{16}/
-];
-function assessTemplateSafety(workflow) {
-  const reasons = [];
-  let worst = "safe";
-  const escalate = (level, reason) => {
-    reasons.push(reason);
-    if (level === "blocked") worst = "blocked";
-    else if (level === "review" && worst === "safe") worst = "review";
-  };
-  for (const node of workflow.nodes) {
-    if (BLOCKED_NODE_TYPES.has(node.type)) {
-      escalate("blocked", `Contains ${node.type} node "${node.name}"`);
-    }
-    if (REVIEW_NODE_TYPES.has(node.type)) {
-      escalate("review", `Contains ${node.type} node "${node.name}"`);
-    }
-    const paramStr = JSON.stringify(node.parameters);
-    for (const pattern of SECRET_PATTERNS) {
-      if (pattern.test(paramStr)) {
-        escalate("blocked", `Node "${node.name}" parameters contain a hardcoded secret`);
-        break;
-      }
-    }
-  }
-  return { trustLevel: worst, reasons };
-}
-
-// src/templates/syncer.ts
-var N8N_TEMPLATE_API = "https://api.n8n.io/api/templates";
-var PAGE_SIZE = 50;
-var DELAY_BETWEEN_FETCHES_MS = 200;
-var DEFAULT_SETTINGS = {
-  executionOrder: "v1",
-  saveManualExecutions: true,
-  timezone: "UTC"
-};
-var TemplateSyncer = class {
-  constructor(library, logger) {
-    this.library = library;
-    this.validator = new N8nValidator();
-    this.logger = logger;
-  }
-  library;
-  validator;
-  logger;
-  async sync(options) {
-    const maxTemplates = options?.maxTemplates ?? 500;
-    await this.library.initialize();
-    const existing = await this.library.list();
-    const existingSourceIds = new Set(
-      existing.filter((w) => w.sourceKind === "n8n-template" && w.sourceId).map((w) => w.sourceId)
-    );
-    const progress = {
-      total: 0,
-      processed: 0,
-      saved: 0,
-      skippedPaid: 0,
-      skippedDuplicate: 0,
-      blocked: 0,
-      reviewed: 0
-    };
-    const templateIds = await this.fetchTemplateIds(maxTemplates, progress);
-    for (const id of templateIds) {
-      if (existingSourceIds.has(String(id))) {
-        progress.skippedDuplicate++;
-        progress.processed++;
-        options?.onProgress?.(progress);
-        continue;
-      }
-      try {
-        await this.processTemplate(id, progress);
-      } catch (err) {
-        this.logger.warn(`Failed to process template ${id}`, { err: String(err) });
-      }
-      progress.processed++;
-      options?.onProgress?.(progress);
-      await new Promise((resolve) => setTimeout(resolve, DELAY_BETWEEN_FETCHES_MS));
-    }
-    return progress;
-  }
-  async fetchTemplateIds(max, progress) {
-    const ids = [];
-    let page = 1;
-    while (ids.length < max) {
-      const url = `${N8N_TEMPLATE_API}/search?page=${page}&rows=${PAGE_SIZE}`;
-      const response = await fetch(url);
-      if (!response.ok) break;
-      const data = await response.json();
-      progress.total = Math.min(data.totalWorkflows, max);
-      for (const template of data.workflows) {
-        if (ids.length >= max) break;
-        if (template.price && template.price > 0) {
-          progress.skippedPaid++;
-          continue;
-        }
-        ids.push(template.id);
-      }
-      if (data.workflows.length < PAGE_SIZE) break;
-      page++;
-      await new Promise((resolve) => setTimeout(resolve, DELAY_BETWEEN_FETCHES_MS));
-    }
-    return ids;
-  }
-  async processTemplate(id, progress) {
-    const url = `${N8N_TEMPLATE_API}/workflows/${id}`;
-    const response = await fetch(url);
-    if (!response.ok) return;
-    const data = await response.json();
-    const templateMeta = data.workflow;
-    const rawWorkflow = templateMeta.workflow;
-    if (!rawWorkflow?.nodes?.length) return;
-    const workflow = {
-      name: templateMeta.name,
-      nodes: rawWorkflow.nodes.filter((n) => n.type && n.name),
-      connections: rawWorkflow.connections,
-      settings: rawWorkflow.settings ? { executionOrder: "v1", ...rawWorkflow.settings } : { ...DEFAULT_SETTINGS }
-    };
-    const validation = this.validator.validate(workflow);
-    const validationErrors = validation.issues.filter((i) => i.severity === "error");
-    if (validationErrors.length > 0) {
-      progress.blocked++;
-      this.logger.debug(`Template ${id} blocked: ${validationErrors.length} validation errors`);
-      return;
-    }
-    const safety = assessTemplateSafety(workflow);
-    if (safety.trustLevel === "blocked") {
-      progress.blocked++;
-      this.logger.debug(`Template ${id} blocked: ${safety.reasons.join(", ")}`);
-      return;
-    }
-    if (safety.trustLevel === "review") {
-      progress.reviewed++;
-    }
-    const description = this.cleanDescription(templateMeta.description);
-    const autoTags = Array.from(new Set(
-      workflow.nodes.flatMap((n) => {
-        const bare = n.type.split(".").pop() ?? "";
-        const tags = [bare];
-        if (n.type.includes("Trigger") || n.type.includes("trigger")) tags.push(`trigger:${bare}`);
-        if (n.type.includes("langchain")) tags.push("ai");
-        return tags;
-      })
-    ));
-    const metadata = {
-      description,
-      tags: autoTags,
-      sourceKind: "n8n-template",
-      sourceId: String(id),
-      sourceUrl: `https://n8n.io/workflows/${id}`,
-      trustLevel: safety.trustLevel
-    };
-    await this.library.save(workflow, metadata);
-    progress.saved++;
-    this.logger.debug(`Template ${id} saved: "${templateMeta.name}" (${safety.trustLevel})`);
-  }
-  cleanDescription(raw) {
-    return raw.replace(/#{1,6}\s*/g, "").replace(/\*{1,2}([^*]+)\*{1,2}/g, "$1").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\n{3,}/g, "\n\n").trim().slice(0, 500);
-  }
-};
-
 export {
-  NullLibrary,
+  generateUUID,
   KairosError,
   ApiError,
   ProviderError,
   N8nApiClient,
   N8nFieldStripper,
-  GuardError,
-  N8nProvider,
   DEFAULT_REGISTRY,
   NodeRegistry,
   N8nValidator,
-  GenerationError,
-  ResponseParseError,
-  ValidationError,
-  TelemetryCollector,
+  scoreToMode,
+  PromptBuilder,
   TelemetryReader,
   nullLogger,
-  Kairos,
   hybridScore,
   clusterWorkflows,
   rerank,
   tokenize,
   buildSearchCorpus,
-  FileLibrary,
-  TemplateSyncer
+  FileLibrary
 };
-//# sourceMappingURL=chunk-QQJDLS5A.js.map
+//# sourceMappingURL=chunk-RYGYNOR6.js.map