@webhouse/cms-ai 0.1.1

package/dist/index.js

@@ -0,0 +1,731 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var PRICING, AnthropicProvider;
+var init_anthropic = __esm({
+  "src/providers/anthropic.ts"() {
+    "use strict";
+    PRICING = {
+      "claude-sonnet-4-6": { input: 3, output: 15 },
+      "claude-haiku-4-5": { input: 0.8, output: 4 },
+      "claude-opus-4-6": { input: 15, output: 75 }
+    };
+    AnthropicProvider = class {
+      name = "anthropic";
+      defaultModel = "claude-sonnet-4-6";
+      client;
+      constructor(apiKey) {
+        this.client = new Anthropic({ apiKey: apiKey ?? process.env["ANTHROPIC_API_KEY"] });
+      }
+      estimateCost(inputTokens, outputTokens, model) {
+        const m = model ?? this.defaultModel;
+        const pricing = PRICING[m] ?? PRICING["claude-sonnet-4-6"];
+        return inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
+      }
+      async generate(prompt, options = {}) {
+        const model = options.model ?? this.defaultModel;
+        const response = await this.client.messages.create({
+          model,
+          max_tokens: options.maxTokens ?? 4096,
+          temperature: options.temperature ?? 0.7,
+          system: options.systemPrompt ?? "You are a helpful content writer.",
+          messages: [{ role: "user", content: prompt }]
+        });
+        const text = response.content.filter((b) => b.type === "text").map((b) => b.text).join("");
+        const inputTokens = response.usage.input_tokens;
+        const outputTokens = response.usage.output_tokens;
+        return {
+          text,
+          inputTokens,
+          outputTokens,
+          model,
+          provider: "anthropic",
+          estimatedCostUsd: this.estimateCost(inputTokens, outputTokens, model)
+        };
+      }
+    };
+  }
+});
+
+// src/providers/openai.ts
+import OpenAI from "openai";
+var PRICING2, OpenAiProvider;
+var init_openai = __esm({
+  "src/providers/openai.ts"() {
+    "use strict";
+    PRICING2 = {
+      "gpt-4o": { input: 2.5, output: 10 },
+      "gpt-4o-mini": { input: 0.15, output: 0.6 }
+    };
+    OpenAiProvider = class {
+      name = "openai";
+      defaultModel = "gpt-4o";
+      client;
+      constructor(apiKey) {
+        this.client = new OpenAI({ apiKey: apiKey ?? process.env["OPENAI_API_KEY"] });
+      }
+      estimateCost(inputTokens, outputTokens, model) {
+        const m = model ?? this.defaultModel;
+        const pricing = PRICING2[m] ?? PRICING2["gpt-4o"];
+        return inputTokens / 1e6 * pricing.input + outputTokens / 1e6 * pricing.output;
+      }
+      async generate(prompt, options = {}) {
+        const model = options.model ?? this.defaultModel;
+        const response = await this.client.chat.completions.create({
+          model,
+          max_tokens: options.maxTokens ?? 4096,
+          temperature: options.temperature ?? 0.7,
+          messages: [
+            ...options.systemPrompt ? [{ role: "system", content: options.systemPrompt }] : [],
+            { role: "user", content: prompt }
+          ]
+        });
+        const text = response.choices[0]?.message.content ?? "";
+        const inputTokens = response.usage?.prompt_tokens ?? 0;
+        const outputTokens = response.usage?.completion_tokens ?? 0;
+        return {
+          text,
+          inputTokens,
+          outputTokens,
+          model,
+          provider: "openai",
+          estimatedCostUsd: this.estimateCost(inputTokens, outputTokens, model)
+        };
+      }
+    };
+  }
+});
+
+// src/providers/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  ProviderRegistry: () => ProviderRegistry
+});
+var ProviderRegistry;
+var init_registry = __esm({
+  "src/providers/registry.ts"() {
+    "use strict";
+    init_anthropic();
+    init_openai();
+    ProviderRegistry = class {
+      providers = /* @__PURE__ */ new Map();
+      defaultProviderName;
+      constructor(config = {}) {
+        if (config.anthropic !== void 0 || process.env["ANTHROPIC_API_KEY"]) {
+          this.providers.set("anthropic", new AnthropicProvider(config.anthropic?.apiKey));
+        }
+        if (config.openai !== void 0 || process.env["OPENAI_API_KEY"]) {
+          this.providers.set("openai", new OpenAiProvider(config.openai?.apiKey));
+        }
+        this.defaultProviderName = config.defaultProvider ?? (this.providers.has("anthropic") ? "anthropic" : "openai");
+      }
+      get(name) {
+        const providerName = name ?? this.defaultProviderName;
+        const provider = this.providers.get(providerName);
+        if (!provider) {
+          throw new Error(
+            `AI provider "${providerName}" not configured. Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable.`
+          );
+        }
+        return provider;
+      }
+      list() {
+        return [...this.providers.keys()];
+      }
+    };
+  }
+});
+
+// src/agents/content.ts
+var content_exports = {};
+__export(content_exports, {
+  ContentAgent: () => ContentAgent
+});
+var ContentAgent;
+var init_content = __esm({
+  "src/agents/content.ts"() {
+    "use strict";
+    ContentAgent = class {
+      constructor(provider) {
+        this.provider = provider;
+      }
+      async generate(prompt, options) {
+        const { collection, locale = "en", tone, targetAudience } = options;
+        const fieldDescriptions = collection.fields.map((f) => {
+          const hint = f.ai?.hint ? ` (${f.ai.hint})` : "";
+          const maxLen = f.ai?.maxLength ?? f.maxLength;
+          const lenHint = maxLen ? ` (max ${maxLen} characters)` : "";
+          return `- "${f.name}" (${f.type})${hint}${lenHint}${f.required === true ? " [required]" : ""}`;
+        }).join("\n");
+        const systemPrompt = [
+          `You are a professional content writer creating content for a CMS.`,
+          `Collection: ${collection.label ?? collection.name}`,
+          tone ? `Tone: ${tone}` : null,
+          targetAudience ? `Target audience: ${targetAudience}` : null,
+          locale !== "en" ? `Language: ${locale}` : null
+        ].filter(Boolean).join("\n");
+        const userPrompt = `Create content for the following request: "${prompt}"
+
+Return a JSON object with these fields:
+${fieldDescriptions}
+
+For "richtext" fields, use Markdown formatting.
+For "date" fields, use ISO 8601 format (e.g. "${(/* @__PURE__ */ new Date()).toISOString()}").
+For "slug", generate a URL-friendly slug from the title (lowercase, hyphens).
+
+Return ONLY valid JSON, no explanation, no markdown code blocks.`;
+        const result = await this.provider.generate(userPrompt, { ...options, systemPrompt });
+        let fields;
+        try {
+          const cleaned = result.text.replace(/^```(?:json)?\n?/m, "").replace(/\n?```$/m, "").trim();
+          fields = JSON.parse(cleaned);
+        } catch {
+          throw new Error(`AI returned invalid JSON: ${result.text.slice(0, 200)}`);
+        }
+        const slug = String(fields["slug"] ?? fields["title"] ?? "untitled").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+        return {
+          fields,
+          slug,
+          usage: {
+            inputTokens: result.inputTokens,
+            outputTokens: result.outputTokens,
+            estimatedCostUsd: result.estimatedCostUsd
+          }
+        };
+      }
+      async rewrite(currentData, options) {
+        const { instruction } = options;
+        const systemPrompt = `You are a professional content editor. Rewrite the provided content according to the instruction.`;
+        const userPrompt = `Current content:
+${JSON.stringify(currentData, null, 2)}
+
+Instruction: "${instruction}"
+
+Return a JSON object with the same field names but updated content. Only update fields that are relevant to the instruction. Return ONLY valid JSON.`;
+        const result = await this.provider.generate(userPrompt, { ...options, systemPrompt });
+        let fields;
+        try {
+          const cleaned = result.text.replace(/^```(?:json)?\n?/m, "").replace(/\n?```$/m, "").trim();
+          fields = JSON.parse(cleaned);
+        } catch {
+          throw new Error(`AI returned invalid JSON: ${result.text.slice(0, 200)}`);
+        }
+        const slug = String(fields["slug"] ?? currentData["slug"] ?? "untitled").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+        return {
+          fields,
+          slug,
+          usage: {
+            inputTokens: result.inputTokens,
+            outputTokens: result.outputTokens,
+            estimatedCostUsd: result.estimatedCostUsd
+          }
+        };
+      }
+      async translate(currentData, targetLocale, options) {
+        return this.rewrite(currentData, {
+          instruction: `Translate all text content to ${targetLocale}. Keep field names in English. Keep dates, numbers, and URLs unchanged.`,
+          ...options
+        });
+      }
+    };
+  }
+});
+
+// src/agents/seo.ts
+var seo_exports = {};
+__export(seo_exports, {
+  SeoAgent: () => SeoAgent
+});
+var SeoAgent;
+var init_seo = __esm({
+  "src/agents/seo.ts"() {
+    "use strict";
+    SeoAgent = class {
+      constructor(provider) {
+        this.provider = provider;
+      }
+      async optimize(doc, siteTitle, baseUrl) {
+        const title = String(doc.data["title"] ?? doc.slug);
+        const content = String(doc.data["content"] ?? doc.data["body"] ?? "").slice(0, 2e3);
+        const excerpt = String(doc.data["excerpt"] ?? "");
+        const systemPrompt = `You are an SEO expert. Generate optimized meta tags and structured data.`;
+        const userPrompt = `Document:
+Title: ${title}
+Excerpt: ${excerpt}
+Content preview: ${content}
+Site: ${siteTitle}
+URL: ${baseUrl}/${doc.collection}/${doc.slug}/
+
+Generate:
+1. metaTitle: SEO-optimized title (50-60 chars)
+2. metaDescription: Compelling description (150-160 chars)
+3. jsonLd: JSON-LD structured data object (Article schema)
+
+Return ONLY valid JSON like:
+{
+  "metaTitle": "...",
+  "metaDescription": "...",
+  "jsonLd": { "@context": "https://schema.org", "@type": "Article", ... }
+}`;
+        const result = await this.provider.generate(userPrompt, {
+          systemPrompt,
+          maxTokens: 1024,
+          temperature: 0.3
+        });
+        let parsed;
+        try {
+          const cleaned = result.text.replace(/^```(?:json)?\n?/m, "").replace(/\n?```$/m, "").trim();
+          parsed = JSON.parse(cleaned);
+        } catch {
+          parsed = {
+            metaTitle: title.slice(0, 60),
+            metaDescription: (excerpt || content).slice(0, 160),
+            jsonLd: {
+              "@context": "https://schema.org",
+              "@type": "Article",
+              headline: title,
+              description: excerpt || content.slice(0, 160)
+            }
+          };
+        }
+        return {
+          ...parsed,
+          usage: {
+            inputTokens: result.inputTokens,
+            outputTokens: result.outputTokens,
+            estimatedCostUsd: result.estimatedCostUsd
+          }
+        };
+      }
+    };
+  }
+});
+
+// src/index.ts
+init_anthropic();
+init_openai();
+init_registry();
+init_content();
+init_seo();
+
+// src/orchestrator/engine.ts
+var FAST_MODEL = "claude-haiku-4-5-20251001";
+function buildFieldDescriptions(collection) {
+  return collection.fields.map((f) => {
+    const hint = f.ai?.hint ? ` (${f.ai.hint})` : "";
+    const maxLen = f.ai?.maxLength ?? f.maxLength;
+    const lenHint = maxLen ? ` (max ${maxLen} characters)` : "";
+    return `- "${f.name}" (${f.type})${hint}${lenHint}${f.required === true ? " [required]" : ""}`;
+  }).join("\n");
+}
+function resolveModel(agent, cockpit) {
+  if (cockpit.speedQuality === "fast") {
+    if (cockpit.primaryModel.startsWith("gpt") || cockpit.primaryModel.startsWith("o1")) {
+      return cockpit.primaryModel;
+    }
+    return FAST_MODEL;
+  }
+  return cockpit.primaryModel;
+}
+function buildSystemPrompt(agent, collection, cockpit, feedbackExamples) {
+  const parts = [];
+  parts.push(agent.systemPrompt);
+  if (agent.behavior.formality > 70) {
+    parts.push("Use formal, professional language.");
+  } else if (agent.behavior.formality < 30) {
+    parts.push("Use casual, conversational language.");
+  }
+  if (agent.behavior.verbosity > 70) {
+    parts.push("Be thorough and detailed in your writing.");
+  } else if (agent.behavior.verbosity < 30) {
+    parts.push("Be concise and to the point.");
+  }
+  if (cockpit.promptDepth === "minimal") {
+  }
+  if (cockpit.promptDepth === "medium" || cockpit.promptDepth === "deep") {
+    parts.push(`Collection: ${collection.label ?? collection.name}`);
+    parts.push(`Fields:
+${buildFieldDescriptions(collection)}`);
+  }
+  if (cockpit.promptDepth === "deep") {
+    if (cockpit.seoWeight > 50) {
+      parts.push(
+        `SEO priority: ${cockpit.seoWeight}%. Optimize for search engines: use target keywords naturally in title, headings, and first paragraph. Write a compelling meta description under 160 characters.`
+      );
+    }
+    if (feedbackExamples && feedbackExamples.length > 0) {
+      const examples = feedbackExamples.slice(-3);
+      parts.push("Learn from these past corrections:");
+      for (const ex of examples) {
+        parts.push(`Original: ${ex.original}
+Corrected: ${ex.corrected}`);
+      }
+    }
+  } else if (cockpit.seoWeight > 50) {
+    parts.push(`Optimize content for SEO (weight: ${cockpit.seoWeight}%).`);
+  }
+  if (cockpit.speedQuality === "thorough") {
+    parts.push(
+      "After generating the content, review it yourself for accuracy, tone, grammar, and completeness. Fix any issues before returning the final version."
+    );
+  }
+  return parts.join("\n\n");
+}
+var OrchestratorEngine = class {
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async run(prompt, agent, collection, cockpit, feedbackExamples) {
+    const systemPrompt = buildSystemPrompt(agent, collection, cockpit, feedbackExamples);
+    const model = resolveModel(agent, cockpit);
+    const fieldDesc = buildFieldDescriptions(collection);
+    const userPrompt = `Create content for: "${prompt}"
+
+Return a JSON object with these fields:
+${fieldDesc}
+
+For "richtext" fields, use Markdown formatting.
+For "date" fields, use ISO 8601 format (e.g. "${(/* @__PURE__ */ new Date()).toISOString()}").
+For "slug", generate a URL-friendly slug from the title (lowercase, hyphens).
+
+Return ONLY valid JSON, no explanation, no markdown code blocks.`;
+    const temperature = agent.behavior.temperature / 100;
+    const result = await this.provider.generate(userPrompt, {
+      systemPrompt,
+      model,
+      temperature
+    });
+    let contentData;
+    try {
+      const cleaned = result.text.replace(/^```(?:json)?\n?/m, "").replace(/\n?```$/m, "").trim();
+      contentData = JSON.parse(cleaned);
+    } catch {
+      throw new Error(`AI returned invalid JSON: ${result.text.slice(0, 200)}`);
+    }
+    const slug = String(contentData["slug"] ?? contentData["title"] ?? "untitled").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+    return {
+      contentData,
+      slug,
+      costUsd: result.estimatedCostUsd
+    };
+  }
+};
+
+// src/orchestrator/queue.ts
+import fs from "fs/promises";
+import path from "path";
+import { randomUUID } from "crypto";
+var CurationQueue = class {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.filePath = path.join(dataDir, "curation-queue.json");
+  }
+  filePath;
+  async list(status) {
+    const items = await this.read();
+    if (status === void 0) return items;
+    return items.filter((i) => i.status === status);
+  }
+  async get(id) {
+    const items = await this.read();
+    return items.find((i) => i.id === id) ?? null;
+  }
+  async add(item) {
+    const items = await this.read();
+    const newItem = {
+      ...item,
+      id: randomUUID(),
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    items.push(newItem);
+    await this.write(items);
+    return newItem;
+  }
+  async updateStatus(id, status, feedback) {
+    const items = await this.read();
+    const idx = items.findIndex((i) => i.id === id);
+    if (idx === -1) throw new Error(`Queue item not found: ${id}`);
+    const item = items[idx];
+    item.status = status;
+    if (feedback !== void 0) {
+      item.rejectionFeedback = feedback;
+    }
+    await this.write(items);
+    return item;
+  }
+  async approve(id, cmsInstance) {
+    const item = await this.updateStatus(id, "approved");
+    await cmsInstance.content.create(item.collection, { ...item.contentData, status: "published" });
+    return await this.updateStatus(id, "published");
+  }
+  async reject(id, feedback) {
+    return this.updateStatus(id, "rejected", feedback);
+  }
+  async getStats() {
+    const items = await this.read();
+    return {
+      ready: items.filter((i) => i.status === "ready").length,
+      in_review: items.filter((i) => i.status === "in_review").length,
+      approved: items.filter((i) => i.status === "approved").length,
+      rejected: items.filter((i) => i.status === "rejected").length,
+      published: items.filter((i) => i.status === "published").length
+    };
+  }
+  async read() {
+    try {
+      const raw = await fs.readFile(this.filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  async write(items) {
+    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    await fs.writeFile(this.filePath, JSON.stringify(items, null, 2));
+  }
+};
+
+// src/orchestrator/runner.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+var AgentRunner = class {
+  constructor(engine, queue, dataDir) {
+    this.engine = engine;
+    this.queue = queue;
+    this.dataDir = dataDir;
+  }
+  async run(agent, collection, cockpit, prompt) {
+    const feedbackExamples = await this.loadFeedback(agent.id);
+    const result = await this.engine.run(prompt, agent, collection, cockpit, feedbackExamples);
+    const shouldAutoPublish = agent.autonomy === "full" && agent.stats.totalGenerated >= 20 && agent.stats.approved + agent.stats.rejected > 0 && agent.stats.approved / (agent.stats.approved + agent.stats.rejected) > 0.95;
+    const status = shouldAutoPublish ? "approved" : "ready";
+    const title = typeof result.contentData["title"] === "string" ? result.contentData["title"] : result.slug;
+    const queueItem = await this.queue.add({
+      agentId: agent.id,
+      agentName: agent.name,
+      collection: collection.name,
+      slug: result.slug,
+      title,
+      status,
+      contentData: result.contentData,
+      costUsd: result.costUsd
+    });
+    return {
+      queueItemId: queueItem.id,
+      agentId: agent.id,
+      collection: collection.name,
+      slug: result.slug,
+      title,
+      contentData: result.contentData,
+      costUsd: result.costUsd,
+      publishedDirectly: shouldAutoPublish
+    };
+  }
+  async loadFeedback(agentId) {
+    const feedbackPath = path2.join(this.dataDir, "agents", agentId, "feedback.json");
+    try {
+      const raw = await fs2.readFile(feedbackPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+};
+
+// src/orchestrator/scheduler.ts
+var WINDOW_MINUTES = 5;
+var AgentScheduler = class {
+  shouldRun(agent, now2) {
+    if (!agent.active || !agent.schedule.enabled) return false;
+    if (agent.schedule.frequency === "manual") return false;
+    if (agent.schedule.frequency === "weekly" && now2.getDay() !== 1) {
+      return false;
+    }
+    const { hours, minutes } = this.parseTime(agent.schedule.time);
+    const nowMinutes = now2.getHours() * 60 + now2.getMinutes();
+    const scheduleMinutes = hours * 60 + minutes;
+    const diff = Math.abs(nowMinutes - scheduleMinutes);
+    return diff <= WINDOW_MINUTES || diff >= 1440 - WINDOW_MINUTES;
+  }
+  getDueAgents(agents, now2) {
+    const timestamp = now2 ?? /* @__PURE__ */ new Date();
+    return agents.filter((a) => this.shouldRun(a, timestamp));
+  }
+  parseTime(timeStr) {
+    const [h, m] = timeStr.split(":");
+    return {
+      hours: parseInt(h ?? "0", 10),
+      minutes: parseInt(m ?? "0", 10)
+    };
+  }
+};
+
+// src/budget/tracker.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+var TokenBudgetTracker = class {
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.filePath = path3.join(dataDir, "ai-budget.json");
+  }
+  filePath;
+  async record(entry) {
+    const data = await this.read();
+    data.entries.push({
+      ...entry,
+      date: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.write(data);
+  }
+  async getCurrentMonthSpent() {
+    const data = await this.read();
+    const now2 = /* @__PURE__ */ new Date();
+    const year = now2.getFullYear();
+    const month = now2.getMonth();
+    return data.entries.filter((e) => {
+      const d = new Date(e.date);
+      return d.getFullYear() === year && d.getMonth() === month;
+    }).reduce((sum, e) => sum + e.costUsd, 0);
+  }
+  async isOverBudget(monthlyLimitUsd) {
+    const spent = await this.getCurrentMonthSpent();
+    return spent >= monthlyLimitUsd;
+  }
+  async getSummary() {
+    const data = await this.read();
+    const currentMonthUsd = await this.getCurrentMonthSpent();
+    const totalUsd = data.entries.reduce((sum, e) => sum + e.costUsd, 0);
+    const byAgent = {};
+    for (const entry of data.entries) {
+      byAgent[entry.agentId] = (byAgent[entry.agentId] ?? 0) + entry.costUsd;
+    }
+    return { currentMonthUsd, totalUsd, byAgent };
+  }
+  async read() {
+    try {
+      const raw = await fs3.readFile(this.filePath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return { monthlyBudgetUsd: 0, entries: [] };
+    }
+  }
+  async write(data) {
+    await fs3.mkdir(path3.dirname(this.filePath), { recursive: true });
+    await fs3.writeFile(this.filePath, JSON.stringify(data, null, 2));
+  }
+};
+
+// src/agents/defaults.ts
+var now = (/* @__PURE__ */ new Date()).toISOString();
+var baseStats = {
+  totalGenerated: 0,
+  approved: 0,
+  rejected: 0,
+  edited: 0
+};
+var baseSchedule = {
+  enabled: false,
+  frequency: "manual",
+  time: "09:00",
+  maxPerRun: 5
+};
+var DEFAULT_AGENTS = [
+  {
+    id: "content-writer",
+    name: "Content Writer",
+    role: "copywriter",
+    systemPrompt: "You are a professional content writer. Write engaging, well-structured content that speaks to the target audience. Use clear headings, short paragraphs, and a natural tone.",
+    behavior: { temperature: 65, formality: 50, verbosity: 60 },
+    tools: { webSearch: false, internalDatabase: true },
+    autonomy: "draft",
+    targetCollections: [],
+    schedule: { ...baseSchedule },
+    stats: { ...baseStats },
+    createdAt: now,
+    updatedAt: now,
+    active: true
+  },
+  {
+    id: "seo-optimizer",
+    name: "SEO Optimizer",
+    role: "seo",
+    systemPrompt: "You are an SEO specialist. Optimize existing content for search engines without compromising readability. Focus on keywords, meta descriptions, heading structure, and internal linking.",
+    behavior: { temperature: 30, formality: 60, verbosity: 40 },
+    tools: { webSearch: true, internalDatabase: true },
+    autonomy: "draft",
+    targetCollections: [],
+    schedule: { ...baseSchedule, frequency: "weekly" },
+    stats: { ...baseStats },
+    createdAt: now,
+    updatedAt: now,
+    active: true
+  },
+  {
+    id: "translator",
+    name: "Translator",
+    role: "translator",
+    systemPrompt: "You are a professional translator. Translate content naturally and idiomatically into the target language. Preserve meaning, tone, and formatting. Adapt cultural references where relevant.",
+    behavior: { temperature: 20, formality: 50, verbosity: 50 },
+    tools: { webSearch: false, internalDatabase: true },
+    autonomy: "draft",
+    targetCollections: [],
+    schedule: { ...baseSchedule },
+    stats: { ...baseStats },
+    createdAt: now,
+    updatedAt: now,
+    active: true
+  },
+  {
+    id: "content-refresher",
+    name: "Content Refresher",
+    role: "refresher",
+    systemPrompt: "You are a specialist in updating and refreshing existing content. Find outdated information, update statistics and facts, improve phrasing, and add relevant new content. Preserve the original tone and structure.",
+    behavior: { temperature: 40, formality: 50, verbosity: 50 },
+    tools: { webSearch: true, internalDatabase: true },
+    autonomy: "draft",
+    targetCollections: [],
+    schedule: { ...baseSchedule, frequency: "weekly", time: "06:00" },
+    stats: { ...baseStats },
+    createdAt: now,
+    updatedAt: now,
+    active: true
+  }
+];
+
+// src/index.ts
+async function createAi(config = {}) {
+  const { ProviderRegistry: ProviderRegistry2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  const { ContentAgent: ContentAgent2 } = await Promise.resolve().then(() => (init_content(), content_exports));
+  const { SeoAgent: SeoAgent2 } = await Promise.resolve().then(() => (init_seo(), seo_exports));
+  const registry = new ProviderRegistry2(config);
+  const provider = registry.get();
+  return {
+    registry,
+    content: new ContentAgent2(provider),
+    seo: new SeoAgent2(provider)
+  };
+}
+export {
+  AgentRunner,
+  AgentScheduler,
+  AnthropicProvider,
+  ContentAgent,
+  CurationQueue,
+  DEFAULT_AGENTS,
+  OpenAiProvider,
+  OrchestratorEngine,
+  ProviderRegistry,
+  SeoAgent,
+  TokenBudgetTracker,
+  createAi
+};
+//# sourceMappingURL=index.js.map