@kat-ai/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2712 @@
+#!/usr/bin/env node
+import * as path10 from 'path';
+import path10__default, { resolve } from 'path';
+import { fileURLToPath } from 'url';
+import * as fs9 from 'fs';
+import { config } from 'dotenv';
+import { Pinecone } from '@pinecone-database/pinecone';
+import { parse } from 'csv-parse/sync';
+import { generateObject, generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { z } from 'zod';
+import { resolveDefaultOpenAiChatModelId, progressiveIntrospect } from '@kat/core';
+import natural from 'natural';
+import { Command, InvalidArgumentError } from 'commander';
+import * as readline from 'readline/promises';
+import { stdout, stdin } from 'process';
+import { readFile } from 'fs/promises';
+
+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 });
+};
+var getFilename, getDirname, __dirname$1;
+var init_esm_shims = __esm({
+  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.8_tsx@4.20.6_typescript@5.9.3_yaml@2.8.1/node_modules/tsup/assets/esm_shims.js"() {
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path10__default.dirname(getFilename());
+    __dirname$1 = /* @__PURE__ */ getDirname();
+  }
+});
+function loadEnv(cwd = process.cwd()) {
+  for (const envPath of ENV_SEARCH_PATHS) {
+    const fullPath = path10.join(cwd, envPath);
+    if (fs9.existsSync(fullPath)) {
+      config({ path: fullPath });
+      return fullPath;
+    }
+  }
+  let current = cwd;
+  while (current !== path10.dirname(current)) {
+    for (const envFile of [".env.local", ".env"]) {
+      const envPath = path10.join(current, envFile);
+      if (fs9.existsSync(envPath)) {
+        config({ path: envPath });
+        return envPath;
+      }
+    }
+    current = path10.dirname(current);
+  }
+  return null;
+}
+function findDataDir(cwd = process.cwd()) {
+  const candidates = [
+    path10.join(cwd, "data"),
+    path10.join(cwd, "examples", "app", "data")
+  ];
+  for (const dir of candidates) {
+    if (fs9.existsSync(dir)) {
+      return dir;
+    }
+  }
+  return null;
+}
+function findManifestsDir(cwd = process.cwd()) {
+  const candidates = [
+    path10.join(cwd, "composition", "manifests"),
+    path10.join(cwd, "examples", "app", "composition", "manifests")
+  ];
+  for (const dir of candidates) {
+    if (fs9.existsSync(dir)) {
+      return dir;
+    }
+  }
+  return null;
+}
+function requireEnv(vars) {
+  const missing = [];
+  const present = [];
+  for (const v of vars) {
+    if (process.env[v]) {
+      present.push(v);
+    } else {
+      missing.push(v);
+    }
+  }
+  return { missing, present };
+}
+function getVersion() {
+  try {
+    const pkgPath = path10.join(import.meta.dirname || __dirname$1, "..", "..", "package.json");
+    if (fs9.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+      return pkg.version || "0.1.0";
+    }
+  } catch {
+  }
+  return "0.1.0";
+}
+var ENV_SEARCH_PATHS;
+var init_config = __esm({
+  "src/utils/config.ts"() {
+    init_esm_shims();
+    ENV_SEARCH_PATHS = [
+      ".env.local",
+      ".env",
+      "examples/app/.env.local",
+      "examples/app/.env"
+    ];
+  }
+});
+
+// src/utils/colors.ts
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function drawBox(content, options = {}) {
+  const lines = Array.isArray(content) ? content : content.split("\n");
+  const padding = options.padding ?? 1;
+  const borderColor = options.borderColor ?? colors.cyan;
+  const contentWidth = Math.max(...lines.map((l) => stripAnsi(l).length));
+  const width = options.width ?? contentWidth + padding * 2;
+  const innerWidth = width;
+  const result = [];
+  if (options.title) {
+    const titleText = ` ${options.title} `;
+    const leftPad = Math.floor((innerWidth - titleText.length) / 2);
+    const rightPad = innerWidth - leftPad - titleText.length;
+    result.push(
+      borderColor(box.topLeft) + borderColor(box.horizontal.repeat(leftPad)) + colors.boldWhite(titleText) + borderColor(box.horizontal.repeat(rightPad)) + borderColor(box.topRight)
+    );
+  } else {
+    result.push(
+      borderColor(box.topLeft) + borderColor(box.horizontal.repeat(innerWidth)) + borderColor(box.topRight)
+    );
+  }
+  const paddingStr = " ".repeat(padding);
+  for (const line of lines) {
+    const strippedLen = stripAnsi(line).length;
+    const rightPadding = Math.max(0, innerWidth - strippedLen - padding * 2);
+    result.push(
+      borderColor(box.vertical) + paddingStr + line + " ".repeat(rightPadding) + paddingStr + borderColor(box.vertical)
+    );
+  }
+  result.push(
+    borderColor(box.bottomLeft) + borderColor(box.horizontal.repeat(innerWidth)) + borderColor(box.bottomRight)
+  );
+  return result.join("\n");
+}
+function printHeader(title, icon) {
+  const prefix = icon ? `${icon} ` : "";
+  console.log("");
+  console.log(colors.boldCyan(`${prefix}${title}`));
+  console.log(colors.cyan(box.horizontal.repeat(stripAnsi(title).length + (icon ? 2 : 0))));
+}
+function printSuccess(message) {
+  console.log(`${colors.green(icons.success)} ${message}`);
+}
+function printError(message) {
+  console.log(`${colors.red(icons.error)} ${message}`);
+}
+function printWarning(message) {
+  console.log(`${colors.yellow(icons.warning)} ${message}`);
+}
+function printInfo(message) {
+  console.log(`${colors.blue(icons.info)} ${message}`);
+}
+function printList(items, color = colors.cyan) {
+  for (const item of items) {
+    console.log(`  ${color(icons.bullet)} ${item}`);
+  }
+}
+function printStep(current, total, message) {
+  const step = colors.gray(`[${current}/${total}]`);
+  console.log(`${step} ${message}`);
+}
+function menuOption(key, label, description) {
+  const keyPart = colors.boldCyan(`[${key}]`);
+  const labelPart = colors.white(label);
+  const descPart = description ? colors.gray(` - ${description}`) : "";
+  return `  ${keyPart} ${labelPart}${descPart}`;
+}
+function printBanner() {
+  const banner = `
+${colors.boldCyan("\u256D\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256E")}
+${colors.boldCyan("\u2502")}${colors.brightMagenta("   \u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557    \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557  ")}${colors.boldCyan("\u2502")}
+${colors.boldCyan("\u2502")}${colors.brightMagenta("   \u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D    \u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557 ")}${colors.boldCyan("\u2502")}
+${colors.boldCyan("\u2502")}${colors.brightMagenta("   \u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557       \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551 ")}${colors.boldCyan("\u2502")}
+${colors.boldCyan("\u2502")}${colors.brightMagenta("   \u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551       \u2588\u2588\u2551   \u2588\u2588\u2551   \u2588\u2588\u2551 ")}${colors.boldCyan("\u2502")}
+${colors.boldCyan("\u2502")}${colors.brightMagenta("   \u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551       \u2588\u2588\u2551   \u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D ")}${colors.boldCyan("\u2502")}
+${colors.boldCyan("\u2502")}${colors.brightMagenta("   \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D       \u255A\u2550\u255D    \u255A\u2550\u2550\u2550\u2550\u2550\u255D  ")}${colors.boldCyan("\u2502")}
+${colors.boldCyan("\u2502")}                                                   ${colors.boldCyan("\u2502")}
+${colors.boldCyan("\u2502")}   ${colors.gray("Knowledge Base Tools")}    ${colors.dim("v0.1.0")}                  ${colors.boldCyan("\u2502")}
+${colors.boldCyan("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F")}
+`;
+  console.log(banner);
+}
+function divider(width = 50) {
+  console.log(colors.gray(box.horizontal.repeat(width)));
+}
+var RESET, BOLD, DIM, ITALIC, UNDERLINE, FG, BG, colors, icons, box, spinnerFrames, Spinner;
+var init_colors = __esm({
+  "src/utils/colors.ts"() {
+    init_esm_shims();
+    RESET = "\x1B[0m";
+    BOLD = "\x1B[1m";
+    DIM = "\x1B[2m";
+    ITALIC = "\x1B[3m";
+    UNDERLINE = "\x1B[4m";
+    FG = {
+      black: "\x1B[30m",
+      red: "\x1B[31m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      blue: "\x1B[34m",
+      magenta: "\x1B[35m",
+      cyan: "\x1B[36m",
+      white: "\x1B[37m",
+      // Bright colors
+      brightBlack: "\x1B[90m",
+      brightRed: "\x1B[91m",
+      brightGreen: "\x1B[92m",
+      brightYellow: "\x1B[93m",
+      brightBlue: "\x1B[94m",
+      brightMagenta: "\x1B[95m",
+      brightCyan: "\x1B[96m",
+      brightWhite: "\x1B[97m"
+    };
+    BG = {
+      black: "\x1B[40m",
+      red: "\x1B[41m",
+      green: "\x1B[42m",
+      yellow: "\x1B[43m",
+      blue: "\x1B[44m",
+      magenta: "\x1B[45m",
+      cyan: "\x1B[46m",
+      white: "\x1B[47m"
+    };
+    colors = {
+      // Basic colors
+      red: (text) => `${FG.red}${text}${RESET}`,
+      green: (text) => `${FG.green}${text}${RESET}`,
+      yellow: (text) => `${FG.yellow}${text}${RESET}`,
+      blue: (text) => `${FG.blue}${text}${RESET}`,
+      magenta: (text) => `${FG.magenta}${text}${RESET}`,
+      cyan: (text) => `${FG.cyan}${text}${RESET}`,
+      white: (text) => `${FG.white}${text}${RESET}`,
+      gray: (text) => `${FG.brightBlack}${text}${RESET}`,
+      // Bright colors
+      brightRed: (text) => `${FG.brightRed}${text}${RESET}`,
+      brightGreen: (text) => `${FG.brightGreen}${text}${RESET}`,
+      brightYellow: (text) => `${FG.brightYellow}${text}${RESET}`,
+      brightBlue: (text) => `${FG.brightBlue}${text}${RESET}`,
+      brightMagenta: (text) => `${FG.brightMagenta}${text}${RESET}`,
+      brightCyan: (text) => `${FG.brightCyan}${text}${RESET}`,
+      // Styles
+      bold: (text) => `${BOLD}${text}${RESET}`,
+      dim: (text) => `${DIM}${text}${RESET}`,
+      italic: (text) => `${ITALIC}${text}${RESET}`,
+      underline: (text) => `${UNDERLINE}${text}${RESET}`,
+      // Combined styles
+      boldRed: (text) => `${BOLD}${FG.red}${text}${RESET}`,
+      boldGreen: (text) => `${BOLD}${FG.green}${text}${RESET}`,
+      boldYellow: (text) => `${BOLD}${FG.yellow}${text}${RESET}`,
+      boldBlue: (text) => `${BOLD}${FG.blue}${text}${RESET}`,
+      boldMagenta: (text) => `${BOLD}${FG.magenta}${text}${RESET}`,
+      boldCyan: (text) => `${BOLD}${FG.cyan}${text}${RESET}`,
+      boldWhite: (text) => `${BOLD}${FG.white}${text}${RESET}`,
+      // Semantic colors
+      success: (text) => `${FG.green}${text}${RESET}`,
+      error: (text) => `${FG.red}${text}${RESET}`,
+      warning: (text) => `${FG.yellow}${text}${RESET}`,
+      info: (text) => `${FG.cyan}${text}${RESET}`,
+      muted: (text) => `${FG.brightBlack}${text}${RESET}`,
+      // Highlight with background
+      highlight: (text) => `${BG.yellow}${FG.black}${text}${RESET}`,
+      badge: (text, color) => {
+        const bg = BG[color] || BG.blue;
+        return `${bg}${FG.white}${BOLD} ${text} ${RESET}`;
+      }
+    };
+    icons = {
+      success: "\u2714",
+      error: "\u2716",
+      warning: "\u26A0",
+      info: "\u2139",
+      question: "?",
+      pointer: "\u276F",
+      bullet: "\u25CF",
+      star: "\u2605",
+      arrow: "\u2192",
+      arrowRight: "\u2192",
+      arrowDown: "\u2193",
+      check: "\u2713",
+      cross: "\u2717",
+      dot: "\xB7",
+      ellipsis: "\u2026",
+      folder: "\u{1F4C1}",
+      file: "\u{1F4C4}",
+      gear: "\u2699",
+      rocket: "\u{1F680}",
+      sparkles: "\u2728",
+      tools: "\u{1F527}",
+      database: "\u{1F5C3}",
+      search: "\u{1F50D}",
+      lightning: "\u26A1",
+      package: "\u{1F4E6}"
+    };
+    box = {
+      topLeft: "\u256D",
+      topRight: "\u256E",
+      bottomLeft: "\u2570",
+      bottomRight: "\u256F",
+      horizontal: "\u2500",
+      vertical: "\u2502",
+      tee: "\u251C",
+      teeRight: "\u2524",
+      cross: "\u253C",
+      top: "\u252C",
+      bottom: "\u2534"
+    };
+    spinnerFrames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+    Spinner = class {
+      frameIndex = 0;
+      interval = null;
+      text;
+      color;
+      constructor(text, color = colors.cyan) {
+        this.text = text;
+        this.color = color;
+      }
+      start() {
+        if (this.interval) return;
+        process.stdout.write("\x1B[?25l");
+        this.interval = setInterval(() => {
+          const frame = spinnerFrames[this.frameIndex];
+          process.stdout.write(`\r${this.color(frame)} ${this.text}`);
+          this.frameIndex = (this.frameIndex + 1) % spinnerFrames.length;
+        }, 80);
+      }
+      update(text) {
+        this.text = text;
+      }
+      stop(finalMessage) {
+        if (this.interval) {
+          clearInterval(this.interval);
+          this.interval = null;
+        }
+        process.stdout.write("\r\x1B[K");
+        process.stdout.write("\x1B[?25h");
+        if (finalMessage) {
+          console.log(finalMessage);
+        }
+      }
+      succeed(text) {
+        this.stop(`${colors.green(icons.success)} ${text || this.text}`);
+      }
+      fail(text) {
+        this.stop(`${colors.red(icons.error)} ${text || this.text}`);
+      }
+      warn(text) {
+        this.stop(`${colors.yellow(icons.warning)} ${text || this.text}`);
+      }
+      info(text) {
+        this.stop(`${colors.blue(icons.info)} ${text || this.text}`);
+      }
+    };
+  }
+});
+
+// src/lib/ingest.ts
+var ingest_exports = {};
+__export(ingest_exports, {
+  ingestData: () => ingestData
+});
+async function ingestData(options) {
+  const { outputMode, localOutputDir, dryRun, verbose, dataDir } = options;
+  const csvFiles = fs9.readdirSync(dataDir).filter((f) => f.endsWith(".csv"));
+  if (csvFiles.length === 0) {
+    printWarning("No CSV files found.");
+    return;
+  }
+  printInfo(`Found ${csvFiles.length} CSV file(s) to process.`);
+  let pinecone = null;
+  if ((outputMode === "pinecone" || outputMode === "both") && !dryRun) {
+    pinecone = new Pinecone({
+      apiKey: process.env.PINECONE_API_KEY
+    });
+  }
+  for (let i = 0; i < csvFiles.length; i++) {
+    const csvFile = csvFiles[i];
+    const csvPath = path10.join(dataDir, csvFile);
+    printStep(i + 1, csvFiles.length, `Processing ${csvFile}...`);
+    const records = await processCSV(csvPath);
+    if (verbose) {
+      printInfo(`  Processed ${records.length} records`);
+    }
+    if (outputMode === "local" || outputMode === "both") {
+      const outputDir = localOutputDir || path10.join(dataDir, "ingested");
+      const kbName = path10.basename(csvFile, ".csv").toLowerCase().replace(/\s+/g, "_");
+      await writeLocalFiles(records, outputDir, kbName, dryRun);
+    }
+    if ((outputMode === "pinecone" || outputMode === "both") && pinecone && !dryRun) {
+      const assistantName = deriveAssistantName(csvFile);
+      await uploadToPinecone(pinecone, records, assistantName);
+    }
+  }
+}
+async function processCSV(csvPath) {
+  const content = fs9.readFileSync(csvPath, "utf-8");
+  const rows = parse(content, {
+    columns: true,
+    skip_empty_lines: true
+  });
+  const records = [];
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    const markdown = rowToMarkdown(row, i + 1);
+    const metadata = extractMetadata(row, i + 1);
+    const filename = `row_${String(i + 1).padStart(4, "0")}.md`;
+    records.push({ filename, markdown, metadata });
+  }
+  return records;
+}
+function rowToMarkdown(row, rowNum) {
+  const lines = [];
+  const title = row.Question || row.Title || row.Name || `Record ${rowNum}`;
+  lines.push(`# ${title}
+`);
+  for (const [key, value] of Object.entries(row)) {
+    if (value && key !== "Question" && key !== "Title" && key !== "Name") {
+      lines.push(`## ${key}
+`);
+      lines.push(`${value}
+`);
+    }
+  }
+  return lines.join("\n");
+}
+function extractMetadata(row, rowNum) {
+  return {
+    row_id: rowNum,
+    ...row
+  };
+}
+async function writeLocalFiles(records, outputDir, kbName, dryRun) {
+  const kbDir = path10.join(outputDir, kbName, "documents");
+  const metaDir = path10.join(outputDir, kbName, "metadata");
+  if (!dryRun) {
+    fs9.mkdirSync(kbDir, { recursive: true });
+    fs9.mkdirSync(metaDir, { recursive: true });
+  }
+  for (const record of records) {
+    if (!dryRun) {
+      fs9.writeFileSync(path10.join(kbDir, record.filename), record.markdown);
+      fs9.writeFileSync(
+        path10.join(metaDir, record.filename.replace(".md", ".json")),
+        JSON.stringify(record.metadata, null, 2)
+      );
+    }
+  }
+  if (!dryRun) {
+    const indexPath = path10.join(outputDir, kbName, "index.json");
+    fs9.writeFileSync(
+      indexPath,
+      JSON.stringify(
+        {
+          name: kbName,
+          recordCount: records.length,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        null,
+        2
+      )
+    );
+  }
+  printSuccess(`  Written ${records.length} files to ${kbDir}`);
+}
+async function uploadToPinecone(pinecone, records, assistantName) {
+  const spinner = new Spinner(`  Uploading to Pinecone assistant: ${assistantName}`, colors.blue);
+  spinner.start();
+  try {
+    let assistant;
+    try {
+      assistant = pinecone.assistant(assistantName);
+    } catch {
+      assistant = await pinecone.createAssistant({
+        name: assistantName,
+        instructions: `You are a helpful assistant for ${assistantName}.`
+      });
+    }
+    for (const record of records) {
+      const blob = new Blob([record.markdown], { type: "text/markdown" });
+      const file = new File([blob], record.filename, { type: "text/markdown" });
+      await assistant.uploadFile(file, {
+        metadata: record.metadata
+      });
+    }
+    spinner.succeed(`  Uploaded ${records.length} files to ${assistantName}`);
+  } catch (error) {
+    spinner.fail(`  Failed to upload to ${assistantName}`);
+    throw error;
+  }
+}
+function deriveAssistantName(csvFile) {
+  return path10.basename(csvFile, ".csv").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+}
+var init_ingest = __esm({
+  "src/lib/ingest.ts"() {
+    init_esm_shims();
+    init_colors();
+  }
+});
+
+// src/lib/compose.ts
+var compose_exports = {};
+__export(compose_exports, {
+  buildComposition: () => buildComposition
+});
+async function buildComposition(options) {
+  const { kbId, domain, description, assistantName, sourcePath, storageMode, dryRun } = options;
+  let sourceDataSample = "";
+  if (sourcePath) {
+    const resolvedPath = resolveSourcePath(sourcePath);
+    if (resolvedPath) {
+      sourceDataSample = await extractDataSample(resolvedPath);
+      printInfo(`Extracted sample from ${resolvedPath}`);
+    }
+  }
+  printStep(1, 3, "Generating manifest with AI...");
+  const manifest = await generateManifest({
+    kbId,
+    domain,
+    description,
+    assistantName,
+    sourceDataSample
+  });
+  printStep(2, 3, "Manifest generated");
+  console.log("\n" + colors.boldWhite("Generated Manifest:"));
+  console.log(colors.gray(JSON.stringify(manifest, null, 2)));
+  if (dryRun) {
+    return { manifest, saved: false };
+  }
+  printStep(3, 3, "Saving manifest...");
+  let savedToLocal = false;
+  let savedToPinecone = false;
+  let outputPath;
+  if (storageMode === "local" || storageMode === "both") {
+    outputPath = await saveManifestLocally(manifest);
+    savedToLocal = true;
+  }
+  if (storageMode === "pinecone" || storageMode === "both") {
+    await saveManifestToPinecone(manifest);
+    savedToPinecone = true;
+  }
+  return {
+    manifest,
+    saved: true,
+    savedToLocal,
+    savedToPinecone,
+    outputPath
+  };
+}
+async function generateManifest(params) {
+  const { kbId, domain, description, assistantName, sourceDataSample } = params;
+  const prompt = `Generate a KB manifest for a knowledge base with the following details:
+
+KB ID: ${kbId}
+Domain: ${domain || "general"}
+Description: ${description || "A knowledge base"}
+Assistant Name: ${assistantName}
+
+${sourceDataSample ? `Sample data from the source:
+${sourceDataSample}
+` : ""}
+
+Create a comprehensive manifest that defines:
+1. What capabilities this KB provides
+2. What input slots it needs (variables like product_type, issue_description, etc.)
+3. What outputs it provides
+4. Slot definitions with descriptions, types, and example values
+5. Relevance hints (keywords that indicate this KB should be used)
+
+The manifest should be practical and help route user queries to this KB when appropriate.`;
+  const { object } = await generateObject({
+    model: openai(resolveDefaultOpenAiChatModelId()),
+    schema: KBManifestSchema,
+    prompt
+  });
+  return object;
+}
+function resolveSourcePath(sourcePath) {
+  if (path10.isAbsolute(sourcePath) && fs9.existsSync(sourcePath)) {
+    return sourcePath;
+  }
+  const dataDir = findDataDir();
+  if (dataDir) {
+    const fullPath = path10.join(dataDir, sourcePath);
+    if (fs9.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  const cwdPath = path10.join(process.cwd(), sourcePath);
+  if (fs9.existsSync(cwdPath)) {
+    return cwdPath;
+  }
+  return null;
+}
+async function extractDataSample(sourcePath) {
+  const content = fs9.readFileSync(sourcePath, "utf-8");
+  if (sourcePath.endsWith(".csv")) {
+    const rows = parse(content, {
+      columns: true,
+      skip_empty_lines: true
+    });
+    const sample = rows.slice(0, 5);
+    return JSON.stringify(sample, null, 2);
+  }
+  return content.slice(0, 2e3);
+}
+async function saveManifestLocally(manifest) {
+  const manifestsDir = findManifestsDir() || path10.join(process.cwd(), "composition", "manifests");
+  fs9.mkdirSync(manifestsDir, { recursive: true });
+  const outputPath = path10.join(manifestsDir, `${manifest.id}.json`);
+  fs9.writeFileSync(outputPath, JSON.stringify(manifest, null, 2));
+  return outputPath;
+}
+async function saveManifestToPinecone(manifest) {
+  const { Pinecone: Pinecone4 } = await import('@pinecone-database/pinecone');
+  const pinecone = new Pinecone4({
+    apiKey: process.env.PINECONE_API_KEY
+  });
+  await pinecone.configureAssistant(manifest.assistantName, {
+    metadata: {
+      kbManifest: JSON.stringify(manifest)
+    }
+  });
+}
+var SlotDefinitionSchema, KBManifestSchema;
+var init_compose = __esm({
+  "src/lib/compose.ts"() {
+    init_esm_shims();
+    init_colors();
+    init_config();
+    SlotDefinitionSchema = z.object({
+      name: z.string(),
+      type: z.enum(["string", "boolean", "enum"]),
+      description: z.string(),
+      prompt: z.string().optional(),
+      examples: z.array(z.string()).optional(),
+      enumValues: z.array(z.string()).optional()
+    });
+    KBManifestSchema = z.object({
+      id: z.string(),
+      assistantName: z.string(),
+      domain: z.string(),
+      description: z.string(),
+      capabilities: z.array(z.string()),
+      inputs: z.array(
+        z.object({
+          slot: z.string(),
+          required: z.boolean().optional(),
+          description: z.string().optional()
+        })
+      ),
+      outputs: z.array(z.string()),
+      slots: z.array(SlotDefinitionSchema),
+      relevance: z.object({
+        goalKeywords: z.array(z.string()).optional(),
+        slotTriggers: z.array(z.string()).optional(),
+        domains: z.array(z.string()).optional()
+      }).optional()
+    });
+  }
+});
+
+// src/lib/introspect.ts
+var introspect_exports = {};
+__export(introspect_exports, {
+  introspectAssistant: () => introspectAssistant
+});
+async function introspectAssistant(options) {
+  const { assistantName, kbId, domain, storageMode, dryRun, verbose } = options;
+  printHeader("Progressive Introspection", icons.search);
+  console.log(`${colors.cyan(icons.bullet)} Assistant: ${colors.white(assistantName)}`);
+  console.log(`${colors.cyan(icons.bullet)} KB ID: ${colors.white(kbId)}`);
+  if (domain) {
+    console.log(`${colors.cyan(icons.bullet)} Domain: ${colors.white(domain)}`);
+  }
+  console.log("");
+  const callbacks = buildCLICallbacks(verbose);
+  const configOverrides = {};
+  if (options.maxDepth !== void 0) configOverrides.maxDepth = options.maxDepth;
+  if (options.maxQuestions !== void 0) configOverrides.maxTotalQuestions = options.maxQuestions;
+  if (options.maxBranch !== void 0) configOverrides.maxBranchFactor = options.maxBranch;
+  if (options.maxRetries !== void 0) configOverrides.maxRetries = options.maxRetries;
+  if (options.llmModel !== void 0 && options.llmModel.trim() !== "") {
+    configOverrides.llmModel = options.llmModel.trim();
+  }
+  const result = await progressiveIntrospect({
+    assistantName,
+    kbId,
+    domain,
+    config: configOverrides,
+    callbacks
+  });
+  console.log("");
+  printHeader("Introspection Summary", icons.check);
+  console.log(`${colors.cyan(icons.bullet)} Questions asked: ${colors.white(String(result.stats.questionsAsked))}`);
+  console.log(`${colors.cyan(icons.bullet)} Categories discovered: ${colors.white(String(result.stats.categoriesDiscovered))}`);
+  console.log(`${colors.cyan(icons.bullet)} Entities discovered: ${colors.white(String(result.stats.entitiesDiscovered))}`);
+  console.log(`${colors.cyan(icons.bullet)} Source files found: ${colors.white(String(result.stats.sourceFilesFound))}`);
+  if (result.state.sourceFiles.size > 0) {
+    console.log("");
+    console.log(colors.boldCyan("  Indexed Documents:"));
+    for (const file of result.state.sourceFiles) {
+      console.log(`    ${colors.green(icons.file)} ${colors.white(file)}`);
+    }
+  }
+  if (result.stats.usage) {
+    printUsageSummary(result.stats.usage);
+  }
+  console.log("");
+  printHeader("Generated Manifest", icons.file);
+  console.log(colors.gray(JSON.stringify(result.manifest, null, 2)));
+  const manifestObj = result.manifest;
+  const localOutputPath = storageMode === "local" || storageMode === "both" ? getLocalManifestOutputPath(manifestObj.id) : void 0;
+  if (dryRun) {
+    return {
+      manifest: result.manifest,
+      saved: false,
+      wouldSaveToLocal: storageMode === "local" || storageMode === "both",
+      wouldSaveToPinecone: storageMode === "pinecone" || storageMode === "both",
+      outputPath: localOutputPath,
+      stats: result.stats
+    };
+  }
+  let savedToLocal = false;
+  let savedToPinecone = false;
+  let outputPath = localOutputPath;
+  if (storageMode === "local" || storageMode === "both") {
+    outputPath = await saveManifestLocally2(result.manifest);
+    savedToLocal = true;
+  }
+  if (storageMode === "pinecone" || storageMode === "both") {
+    await saveManifestToPinecone2(result.manifest);
+    savedToPinecone = true;
+  }
+  return {
+    manifest: result.manifest,
+    saved: true,
+    savedToLocal,
+    savedToPinecone,
+    outputPath,
+    stats: result.stats
+  };
+}
+function buildCLICallbacks(verbose) {
+  let currentPhase = "";
+  let phaseSpinner = null;
+  return {
+    onPhaseStart: (phase, assistantName) => {
+      if (phaseSpinner) {
+        phaseSpinner.succeed(`${currentPhase} complete`);
+      }
+      const phaseLabels = {
+        seed_discovery: "Phase 1: Seed Discovery",
+        entity_expansion: "Phase 2: Entity Expansion",
+        relationship_discovery: "Phase 3: Relationship Discovery",
+        abstraction_refinement: "Phase 4: Manifest Inference",
+        enum_extraction: "Phase 5: Enum Extraction",
+        manifest_generation: "Phase 6: Manifest Synthesis"
+      };
+      currentPhase = phaseLabels[phase] || phase;
+      console.log("");
+      printHeader(currentPhase, icons.sparkles);
+      if (!verbose) {
+        phaseSpinner = new Spinner(`${currentPhase}...`, colors.blue);
+        phaseSpinner.start();
+      }
+    },
+    onPhaseProgress: (phase, message) => {
+      if (verbose) {
+        console.log(`  ${colors.gray("\u21B3")} ${colors.gray(message)}`);
+      } else if (phaseSpinner) {
+        phaseSpinner.update(message);
+      }
+    },
+    onQuestion: (questionNum, totalBudget, question, objective) => {
+      if (verbose) {
+        console.log("");
+        const objectiveLabel = objective.replace(/_/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+        printStep(questionNum, totalBudget, colors.cyan(objectiveLabel));
+        console.log(`  ${colors.boldWhite("Question:")} ${colors.white(question)}`);
+      } else if (phaseSpinner) {
+        phaseSpinner.update(`${currentPhase} (Q${questionNum}/${totalBudget})...`);
+      }
+    },
+    onAnswer: (questionNum, answer) => {
+      if (verbose) {
+        console.log(`  ${colors.green(icons.check)} ${colors.boldWhite("Answer Preview:")}`);
+        for (const line of formatAnswerPreview(answer)) {
+          console.log(`    ${colors.white(line)}`);
+        }
+        console.log(`    ${colors.gray(`(${answer.length} chars total)`)}`);
+      }
+    },
+    onValidation: (questionNum, validation) => {
+      if (verbose) {
+        const classColor = validation.isValid ? colors.green : colors.yellow;
+        console.log(`  ${colors.gray("Validation:")} ${classColor(validation.classification)} (${(validation.confidence * 100).toFixed(0)}% confidence)`);
+        if (!validation.isValid && validation.suggestedRetryStrategy) {
+          console.log(`  ${colors.gray("Retry strategy:")} ${colors.white(validation.suggestedRetryStrategy)}`);
+        }
+        if (validation.newInformation) {
+          console.log(`  ${colors.gray("New information:")} ${colors.white(validation.newInformation)}`);
+        }
+        if (validation.extractedCategories.length > 0) {
+          console.log(`  ${colors.gray("Categories:")} ${colors.white(validation.extractedCategories.join(", "))}`);
+        }
+        if (validation.extractedEntities.length > 0) {
+          console.log(`  ${colors.gray("Entities:")} ${colors.white(validation.extractedEntities.slice(0, 5).join(", "))}${validation.extractedEntities.length > 5 ? "..." : ""}`);
+        }
+      }
+    },
+    onDiscovery: (categories, entities, sourceFiles) => {
+      if (verbose) {
+        console.log(
+          `  ${colors.gray("Discovery:")} ${colors.white(`${categories} categories, ${entities} entities, ${sourceFiles} source files`)}`
+        );
+      } else if (phaseSpinner) {
+        phaseSpinner.update(`${currentPhase} (${categories} categories, ${entities} entities)...`);
+      }
+    },
+    onManifestStep: (step, totalSteps, description) => {
+      if (verbose) {
+        printStep(step, totalSteps, description);
+      } else if (phaseSpinner) {
+        phaseSpinner.update(`Generating manifest (${step}/${totalSteps})...`);
+      }
+    },
+    onError: (assistantName, error) => {
+      if (phaseSpinner) {
+        phaseSpinner.fail(`Error: ${error}`);
+        phaseSpinner = null;
+      }
+      printWarning(`Error for ${assistantName}: ${error}`);
+    },
+    onComplete: (assistantName, manifest) => {
+      if (phaseSpinner) {
+        phaseSpinner.succeed("Manifest generation complete");
+        phaseSpinner = null;
+      }
+    }
+  };
+}
+function formatAnswerPreview(answer, maxLines = 8, maxChars = 1200) {
+  const cleaned = answer.trim();
+  if (!cleaned) {
+    return ["(empty response)"];
+  }
+  const lines = cleaned.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const previewLines = [];
+  let consumed = 0;
+  for (const line of lines) {
+    if (previewLines.length >= maxLines || consumed >= maxChars) {
+      break;
+    }
+    const remaining = maxChars - consumed;
+    if (line.length <= remaining) {
+      previewLines.push(line);
+      consumed += line.length;
+      continue;
+    }
+    const clipped = `${line.slice(0, Math.max(0, remaining - 1)).trimEnd()}\u2026`;
+    previewLines.push(clipped);
+    consumed = maxChars;
+    break;
+  }
+  if (lines.length > previewLines.length || cleaned.length > maxChars) {
+    previewLines.push("\u2026");
+  }
+  return previewLines;
+}
+function formatCost(cost) {
+  if (cost < 0.01) {
+    return `$${cost.toFixed(4)}`;
+  }
+  return `$${cost.toFixed(2)}`;
+}
+function formatTokens(count) {
+  return count.toLocaleString();
+}
+function printUsageSummary(usage) {
+  console.log("");
+  printHeader("LLM Usage Summary", icons.sparkles);
+  console.log(`${colors.cyan(icons.bullet)} Total cost: ${colors.white(formatCost(usage.totalCost))}`);
+  console.log(`${colors.cyan(icons.bullet)} Total tokens: ${colors.white(formatTokens(usage.totalTokens.totalTokens))} (${formatTokens(usage.totalTokens.promptTokens)} in / ${formatTokens(usage.totalTokens.completionTokens)} out)`);
+  console.log(`${colors.cyan(icons.bullet)} Total LLM calls: ${colors.white(String(usage.entries.length))}`);
+  const providers = Object.entries(usage.byProvider);
+  if (providers.length > 0) {
+    console.log("");
+    console.log(colors.boldCyan("  By Provider:"));
+    for (const [provider, data] of providers) {
+      const costStr = data.cost > 0 ? ` (${formatCost(data.cost)})` : "";
+      console.log(`    ${colors.gray(provider + ":")} ${colors.white(formatTokens(data.tokens.totalTokens))} tokens${costStr} [${data.calls} calls]`);
+    }
+  }
+  const phases = Object.entries(usage.byPhase);
+  if (phases.length > 0) {
+    const phaseLabels = {
+      seed_discovery: "Seed Discovery",
+      entity_expansion: "Entity Expansion",
+      relationship_discovery: "Relationship Discovery",
+      manifest_inference: "Manifest Inference",
+      manifest_generation: "Manifest Generation"
+    };
+    console.log("");
+    console.log(colors.boldCyan("  By Phase:"));
+    for (const [phase, data] of phases) {
+      const label = phaseLabels[phase] || phase;
+      const costStr = data.cost > 0 ? formatCost(data.cost) : "$0.00";
+      console.log(`    ${colors.gray(label + ":")} ${colors.white(costStr)} (${data.calls} calls, ${formatTokens(data.tokens.totalTokens)} tokens)`);
+    }
+  }
+}
+async function saveManifestLocally2(manifest) {
+  const manifestObj = manifest;
+  const outputPath = getLocalManifestOutputPath(manifestObj.id);
+  fs9.mkdirSync(path10.dirname(outputPath), { recursive: true });
+  fs9.writeFileSync(outputPath, JSON.stringify(manifest, null, 2));
+  return outputPath;
+}
+function getLocalManifestOutputPath(manifestId) {
+  const manifestsDir = findManifestsDir() || path10.join(process.cwd(), "composition", "manifests");
+  return path10.join(manifestsDir, `${manifestId}.json`);
+}
+async function saveManifestToPinecone2(manifest) {
+  const pinecone = new Pinecone({
+    apiKey: process.env.PINECONE_API_KEY
+  });
+  const manifestObj = manifest;
+  await pinecone.configureAssistant(manifestObj.assistantName, {
+    metadata: {
+      kbManifest: JSON.stringify(manifest)
+    }
+  });
+}
+var init_introspect = __esm({
+  "src/lib/introspect.ts"() {
+    init_esm_shims();
+    init_colors();
+    init_config();
+  }
+});
+
+// src/lib/validate.ts
+var validate_exports = {};
+__export(validate_exports, {
+  validateData: () => validateData
+});
+async function validateData(options = {}) {
+  const dataDir = options.path || findDataDir();
+  const results = [];
+  if (!dataDir || !fs9.existsSync(dataDir)) {
+    return {
+      results: [
+        {
+          name: "Data Directory",
+          valid: false,
+          records: 0,
+          issues: [`Data directory not found: ${dataDir || "unknown"}`]
+        }
+      ],
+      allValid: false
+    };
+  }
+  const csvFiles = fs9.readdirSync(dataDir).filter((f) => f.endsWith(".csv"));
+  for (const csvFile of csvFiles) {
+    const csvPath = path10.join(dataDir, csvFile);
+    const result = validateCSV(csvPath, csvFile);
+    results.push(result);
+  }
+  const allValid = results.every((r) => r.valid);
+  return { results, allValid };
+}
+function validateCSV(csvPath, filename) {
+  const issues = [];
+  let records = 0;
+  try {
+    const content = fs9.readFileSync(csvPath, "utf-8");
+    const rows = parse(content, {
+      columns: true,
+      skip_empty_lines: true
+    });
+    records = rows.length;
+    if (records === 0) {
+      issues.push("CSV file is empty");
+    }
+    const headers = Object.keys(rows[0] || {});
+    if (headers.length === 0) {
+      issues.push("CSV file has no columns");
+    }
+    const recommendedColumns = ["Question", "Answer", "Category", "Title", "Description"];
+    const hasRecommended = recommendedColumns.some(
+      (col) => headers.some((h) => h.toLowerCase() === col.toLowerCase())
+    );
+    if (!hasRecommended) {
+      issues.push(
+        `CSV has no standard columns. Found: ${headers.join(", ")}. Consider adding: ${recommendedColumns.join(", ")}`
+      );
+    }
+    const emptyCheck = {};
+    for (const row of rows) {
+      for (const [key, value] of Object.entries(row)) {
+        if (!value || value.trim() === "") {
+          emptyCheck[key] = (emptyCheck[key] || 0) + 1;
+        }
+      }
+    }
+    for (const [col, count] of Object.entries(emptyCheck)) {
+      if (count > records * 0.1) {
+        issues.push(`Column "${col}" has ${count}/${records} empty values`);
+      }
+    }
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      for (const [key, value] of Object.entries(row)) {
+        if (value && value.length > 5e4) {
+          issues.push(`Row ${i + 1}, column "${key}" has very long content (${value.length} chars)`);
+        }
+      }
+    }
+  } catch (error) {
+    issues.push(`Failed to parse CSV: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return {
+    name: filename,
+    valid: issues.length === 0,
+    records,
+    issues
+  };
+}
+var init_validate = __esm({
+  "src/lib/validate.ts"() {
+    init_esm_shims();
+    init_config();
+  }
+});
+
+// src/lib/topics.ts
+var topics_exports = {};
+__export(topics_exports, {
+  testTopics: () => testTopics
+});
+async function testTopics(options) {
+  const { paths, mode = "classic", topN, verbose, json } = options;
+  const results = [];
+  for (const inputPath of paths) {
+    const resolvedPath = path10.resolve(inputPath);
+    if (!fs9.existsSync(resolvedPath)) {
+      console.log(colors.red(`Path not found: ${resolvedPath}`));
+      continue;
+    }
+    const stat = fs9.statSync(resolvedPath);
+    if (stat.isDirectory()) {
+      const files = fs9.readdirSync(resolvedPath);
+      for (const file of files) {
+        const filePath = path10.join(resolvedPath, file);
+        if (fs9.statSync(filePath).isFile()) {
+          const result = await processFile(filePath, mode, topN, verbose);
+          results.push(result);
+        }
+      }
+    } else {
+      const result = await processFile(resolvedPath, mode, topN, verbose);
+      results.push(result);
+    }
+  }
+  if (json) {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    printResults(results, verbose);
+  }
+}
+async function processFile(filePath, mode, topN, verbose) {
+  const content = fs9.readFileSync(filePath, "utf-8");
+  const preview = verbose ? content.slice(0, 200) + "..." : void 0;
+  let topics;
+  switch (mode) {
+    case "classic":
+      topics = extractTopicsClassic(content, topN);
+      break;
+    case "slm":
+      topics = await extractTopicsSLM(content, topN);
+      break;
+    case "hybrid":
+      const classicTopics = extractTopicsClassic(content, topN);
+      const slmTopics = await extractTopicsSLM(content, topN);
+      topics = [.../* @__PURE__ */ new Set([...classicTopics, ...slmTopics])].slice(0, topN);
+      break;
+    default:
+      topics = extractTopicsClassic(content, topN);
+  }
+  return {
+    file: path10.basename(filePath),
+    topics,
+    method: mode,
+    preview
+  };
+}
+function extractTopicsClassic(content, topN) {
+  const TfIdf = natural.TfIdf;
+  const tfidf = new TfIdf();
+  tfidf.addDocument(content);
+  const terms = [];
+  tfidf.listTerms(0).forEach((item) => {
+    if (item.term.length > 2 && !isStopword(item.term)) {
+      terms.push({ term: item.term, score: item.tfidf });
+    }
+  });
+  terms.sort((a, b) => b.score - a.score);
+  return terms.slice(0, topN).map((t) => t.term);
+}
+async function extractTopicsSLM(content, topN) {
+  const truncatedContent = content.slice(0, 4e3);
+  const { text } = await generateText({
+    model: openai(resolveDefaultOpenAiChatModelId()),
+    prompt: `Extract the top ${topN} most important topics from the following document. 
+Return only the topics as a comma-separated list, without any additional text or explanation.
+
+Document:
+${truncatedContent}`
+  });
+  return text.split(",").map((t) => t.trim()).filter(Boolean).slice(0, topN);
+}
+function isStopword(word) {
+  const stopwords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "and",
+    "or",
+    "but",
+    "in",
+    "on",
+    "at",
+    "to",
+    "for",
+    "of",
+    "with",
+    "by",
+    "from",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "must",
+    "shall",
+    "can",
+    "this",
+    "that",
+    "these",
+    "those",
+    "i",
+    "you",
+    "he",
+    "she",
+    "it",
+    "we",
+    "they",
+    "what",
+    "which",
+    "who",
+    "when",
+    "where",
+    "why",
+    "how",
+    "all",
+    "each",
+    "every",
+    "both",
+    "few",
+    "more",
+    "most",
+    "other",
+    "some",
+    "such",
+    "no",
+    "nor",
+    "not",
+    "only",
+    "own",
+    "same",
+    "so",
+    "than",
+    "too",
+    "very",
+    "just"
+  ]);
+  return stopwords.has(word.toLowerCase());
+}
+function printResults(results, verbose) {
+  for (const result of results) {
+    divider();
+    console.log(colors.boldWhite(result.file));
+    console.log(colors.gray(`Method: ${result.method}`));
+    if (verbose && result.preview) {
+      console.log(colors.gray("\nPreview:"));
+      console.log(colors.dim(result.preview));
+    }
+    console.log(colors.cyan("\nTopics:"));
+    for (const topic of result.topics) {
+      console.log(`  ${colors.green("\u2022")} ${topic}`);
+    }
+  }
+  divider();
+}
+var init_topics = __esm({
+  "src/lib/topics.ts"() {
+    init_esm_shims();
+    init_colors();
+  }
+});
+
+// src/lib/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  listManifests: () => listManifests,
+  syncManifests: () => syncManifests
+});
+async function listManifests() {
+  const local = [];
+  const pinecone = [];
+  const manifestsDir = findManifestsDir();
+  if (manifestsDir && fs9.existsSync(manifestsDir)) {
+    const files = fs9.readdirSync(manifestsDir).filter((f) => f.endsWith(".json"));
+    for (const file of files) {
+      try {
+        const content = fs9.readFileSync(path10.join(manifestsDir, file), "utf-8");
+        const manifest = JSON.parse(content);
+        local.push({
+          id: manifest.id || path10.basename(file, ".json"),
+          assistantName: manifest.assistantName || "",
+          source: "local"
+        });
+      } catch {
+      }
+    }
+  }
+  try {
+    const pc = new Pinecone({
+      apiKey: process.env.PINECONE_API_KEY
+    });
+    const assistants = await pc.listAssistants();
+    for (const assistant of assistants.assistants || []) {
+      try {
+        const details = await pc.describeAssistant(assistant.name);
+        if (details.metadata?.kbManifest) {
+          const manifest = JSON.parse(details.metadata.kbManifest);
+          pinecone.push({
+            id: manifest.id || assistant.name,
+            assistantName: assistant.name,
+            source: "pinecone"
+          });
+        }
+      } catch {
+      }
+    }
+  } catch (error) {
+    printInfo("Could not list Pinecone assistants");
+  }
+  return { local, pinecone };
+}
+async function syncManifests(direction, options = {}) {
+  const { dryRun } = options;
+  const errors = [];
+  let synced = 0;
+  const pc = new Pinecone({
+    apiKey: process.env.PINECONE_API_KEY
+  });
+  const manifestsDir = findManifestsDir() || path10.join(process.cwd(), "composition", "manifests");
+  if (direction === "toLocal" || direction === "both") {
+    printStep(1, 2, "Downloading manifests from Pinecone...");
+    try {
+      const assistants = await pc.listAssistants();
+      for (const assistant of assistants.assistants || []) {
+        try {
+          const details = await pc.describeAssistant(assistant.name);
+          if (details.metadata?.kbManifest) {
+            const manifest = JSON.parse(details.metadata.kbManifest);
+            if (!dryRun) {
+              fs9.mkdirSync(manifestsDir, { recursive: true });
+              const outputPath = path10.join(manifestsDir, `${manifest.id || assistant.name}.json`);
+              fs9.writeFileSync(outputPath, JSON.stringify(manifest, null, 2));
+            }
+            synced++;
+            printInfo(`  ${dryRun ? "Would sync" : "Synced"}: ${assistant.name}`);
+          }
+        } catch (error) {
+          errors.push(`Failed to sync ${assistant.name}: ${error}`);
+        }
+      }
+    } catch (error) {
+      errors.push(`Failed to list assistants: ${error}`);
+    }
+  }
+  if (direction === "toPinecone" || direction === "both") {
+    printStep(direction === "both" ? 2 : 1, direction === "both" ? 2 : 1, "Uploading manifests to Pinecone...");
+    if (fs9.existsSync(manifestsDir)) {
+      const files = fs9.readdirSync(manifestsDir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        try {
+          const content = fs9.readFileSync(path10.join(manifestsDir, file), "utf-8");
+          const manifest = JSON.parse(content);
+          if (manifest.assistantName) {
+            if (!dryRun) {
+              await pc.configureAssistant(manifest.assistantName, {
+                metadata: {
+                  kbManifest: JSON.stringify(manifest)
+                }
+              });
+            }
+            synced++;
+            printInfo(`  ${dryRun ? "Would sync" : "Synced"}: ${manifest.id}`);
+          }
+        } catch (error) {
+          errors.push(`Failed to sync ${file}: ${error}`);
+        }
+      }
+    }
+  }
+  return { synced, errors };
+}
+var init_sync = __esm({
+  "src/lib/sync.ts"() {
+    init_esm_shims();
+    init_config();
+    init_colors();
+  }
+});
+
+// src/lib/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  generateApp: () => generateApp
+});
+function getTemplatePath(template) {
+  const templateName = template === "vercel-ai" ? "app-vercel-ai" : "app";
+  const possiblePaths = [
+    // From packages/cli/dist (bundled)
+    path10.resolve(import.meta.dirname || __dirname2, "..", "..", "..", "examples", templateName),
+    // From packages/cli/src/lib (source)  
+    path10.resolve(import.meta.dirname || __dirname2, "..", "..", "..", "..", "examples", templateName),
+    // From project root (when cwd is project root)
+    path10.resolve(process.cwd(), "examples", templateName),
+    // Up from cwd
+    path10.resolve(process.cwd(), "..", "examples", templateName),
+    path10.resolve(process.cwd(), "..", "..", "examples", templateName)
+  ];
+  for (const templatePath of possiblePaths) {
+    if (fs9.existsSync(templatePath)) {
+      return templatePath;
+    }
+  }
+  return possiblePaths[0];
+}
+async function generateAgentConfig(options) {
+  const { name, description, domain } = options;
+  const prompt = `Generate a complete agent configuration for a knowledge-base powered assistant app.
+
+App Name: ${name}
+Description: ${description}  
+Domain: ${domain}
+
+Create a JSON configuration that includes:
+1. Appropriate system prompts for the domain
+2. 4-6 realistic user goals/intents (with name and description)
+3. 5-8 extraction slots relevant to the domain
+4. Error messages appropriate for the domain
+5. 5-7 example questions users might ask
+6. Sensible default behaviors
+
+The configuration should be practical and help the app understand and respond to user queries in the ${domain} domain.`;
+  try {
+    const { object } = await generateObject({
+      model: openai(resolveDefaultOpenAiChatModelId()),
+      schema: AgentConfigSchema,
+      prompt
+    });
+    return object;
+  } catch (error) {
+    console.error("LLM generation failed, using defaults:", error instanceof Error ? error.message : error);
+    return createDefaultConfig(name, description, domain);
+  }
+}
+function createDefaultConfig(name, description, domain) {
+  const kbId = `kb-${domain.toLowerCase().replace(/\s+/g, "-")}`;
+  const defaultModel = resolveDefaultOpenAiChatModelId();
+  return {
+    name,
+    description,
+    domain,
+    llm: {
+      provider: "openai",
+      models: {
+        planning: defaultModel,
+        extraction: defaultModel,
+        synthesis: defaultModel,
+        questionGeneration: defaultModel
+      }
+    },
+    prompts: {
+      plannerSystemRole: `an expert ${domain} assistant`,
+      synthesisSystemRole: `a knowledgeable ${domain} specialist helping users with their questions`,
+      planningInstructions: `Consider the user's needs in the ${domain} domain. Look for relevant information and examples.`,
+      synthesisInstructions: `Provide clear, helpful responses. Reference specific sources when available.`,
+      extractionInstructions: `Identify the topic, specific issue, and any relevant context from the user's query.`
+    },
+    goals: [
+      { name: "get_information", description: "User wants to learn about a topic" },
+      { name: "solve_problem", description: "User needs help solving a specific issue" },
+      { name: "find_resource", description: "User is looking for a specific resource or reference" },
+      { name: "compare_options", description: "User wants to compare different options or approaches" }
+    ],
+    messages: {
+      allKBsFailed: `I apologize, but I encountered an issue accessing the information needed to answer your question. Please try again or rephrase your question.`,
+      noRelevantInfo: `I couldn't find specific information about that topic in the available knowledge base. Could you rephrase your question or provide more context?`,
+      synthesisError: `I encountered an error while preparing the answer. Please try asking your question again.`
+    },
+    slots: [
+      {
+        name: "topic",
+        type: "string",
+        required: true,
+        description: "The main topic of the query",
+        prompt: "What topic are you asking about?",
+        examples: ["general inquiry", "specific issue", "how-to question"]
+      },
+      {
+        name: "context",
+        type: "string",
+        required: false,
+        description: "Additional context for the query",
+        prompt: "Can you provide more context?",
+        examples: ["background info", "related details"]
+      }
+    ],
+    slotPriority: ["topic", "context"],
+    defaultKbId: kbId,
+    citations: {
+      format: "brackets",
+      labelPrefix: "S"
+    },
+    behavior: {
+      maxDisambiguationAttempts: 3,
+      fallbackStrategy: "use_first",
+      enablePlanModification: true
+    },
+    quickQuestions: [
+      `What can you help me with in ${domain}?`,
+      `How do I get started?`,
+      `Can you explain the basics?`,
+      `What are common issues people face?`,
+      `Where can I find more information?`
+    ]
+  };
+}
+function copyTemplate(src, dest) {
+  if (!fs9.existsSync(src)) {
+    throw new Error(`Template directory not found: ${src}`);
+  }
+  fs9.mkdirSync(dest, { recursive: true });
+  const entries = fs9.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path10.join(src, entry.name);
+    const destPath = path10.join(dest, entry.name);
+    if (EXCLUDED_PATHS.includes(entry.name)) {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      copyTemplate(srcPath, destPath);
+    } else {
+      fs9.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+function updatePackageJson(outputDir, name) {
+  const packageJsonPath = path10.join(outputDir, "package.json");
+  if (!fs9.existsSync(packageJsonPath)) {
+    return;
+  }
+  const packageJson = JSON.parse(fs9.readFileSync(packageJsonPath, "utf-8"));
+  const packageName = name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  packageJson.name = `@kat/${packageName}`;
+  packageJson.description = `${name} - A KAT-powered assistant`;
+  fs9.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n");
+}
+function updateLayout(outputDir, name, description) {
+  const layoutPath = path10.join(outputDir, "app", "layout.tsx");
+  if (!fs9.existsSync(layoutPath)) {
+    return;
+  }
+  let content = fs9.readFileSync(layoutPath, "utf-8");
+  content = content.replace(
+    /title:\s*['"][^'"]*['"]/,
+    `title: '${name}'`
+  );
+  content = content.replace(
+    /description:\s*['"][^'"]*['"]/,
+    `description: '${description}'`
+  );
+  fs9.writeFileSync(layoutPath, content);
+}
+function createEnvExample(outputDir) {
+  const envContent = `# OpenAI API Key (required)
+OPENAI_API_KEY=your-openai-api-key
+
+# Pinecone API Key (required for KB access)
+PINECONE_API_KEY=your-pinecone-api-key
+
+# Optional: Pinecone Environment
+# PINECONE_ENVIRONMENT=us-east-1
+`;
+  fs9.writeFileSync(path10.join(outputDir, ".env.example"), envContent);
+}
+function createSampleManifest(outputDir, domain) {
+  const manifestsDir = path10.join(outputDir, "composition", "manifests");
+  fs9.mkdirSync(manifestsDir, { recursive: true });
+  const kbId = `kb-${domain.toLowerCase().replace(/\s+/g, "-")}`;
+  const sampleManifest = {
+    id: kbId,
+    assistantName: kbId,
+    domain,
+    description: `Knowledge base for ${domain}`,
+    capabilities: [
+      `Answer questions about ${domain}`,
+      "Provide relevant information and guidance",
+      "Reference source documents"
+    ],
+    inputs: [
+      { slot: "topic", required: true, description: "The specific topic being asked about" },
+      { slot: "context", required: false, description: "Additional context for the query" }
+    ],
+    outputs: [
+      "Detailed answers with citations",
+      "Relevant document references"
+    ],
+    slots: [
+      {
+        name: "topic",
+        type: "string",
+        description: "The main topic of the query"
+      }
+    ],
+    relevance: {
+      slotTriggers: ["topic"],
+      domains: [domain]
+    }
+  };
+  fs9.writeFileSync(
+    path10.join(manifestsDir, `${kbId}.json`),
+    JSON.stringify(sampleManifest, null, 2) + "\n"
+  );
+}
+async function generateApp(options) {
+  const { name, description, domain, template, outputDir } = options;
+  const totalSteps = 5;
+  const outputPath = path10.resolve(process.cwd(), outputDir);
+  printStep(1, totalSteps, "Generating agent configuration with AI...");
+  const config2 = await generateAgentConfig(options);
+  printStep(2, totalSteps, `Copying ${template} template...`);
+  const templatePath = getTemplatePath(template);
+  copyTemplate(templatePath, outputPath);
+  printStep(3, totalSteps, "Writing agent.config.json...");
+  const configPath = path10.join(outputPath, "agent.config.json");
+  fs9.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n");
+  printStep(4, totalSteps, "Customizing app files...");
+  updatePackageJson(outputPath, name);
+  updateLayout(outputPath, name, description);
+  createEnvExample(outputPath);
+  printStep(5, totalSteps, "Creating sample KB manifest...");
+  createSampleManifest(outputPath, domain);
+  printInfo(`Template: ${template === "vercel-ai" ? "Vercel AI SDK" : "Native Next.js"}`);
+  return {
+    success: true,
+    outputPath,
+    configPath
+  };
+}
+var __dirname2, GoalSchema, SlotSchema, AgentConfigSchema, EXCLUDED_PATHS;
+var init_generate = __esm({
+  "src/lib/generate.ts"() {
+    init_esm_shims();
+    init_colors();
+    __dirname2 = import.meta.dirname || path10.dirname(new URL(import.meta.url).pathname);
+    GoalSchema = z.object({
+      name: z.string().describe("Snake_case identifier for the goal"),
+      description: z.string().describe("Human-readable description of what the user wants")
+    });
+    SlotSchema = z.object({
+      name: z.string().describe("Snake_case identifier for the slot"),
+      type: z.string().describe("Data type of the slot: string, boolean, or number"),
+      required: z.boolean().describe("Whether this slot is required"),
+      description: z.string().describe("What this slot represents"),
+      prompt: z.string().optional().describe("Question to ask the user to fill this slot"),
+      examples: z.array(z.string()).optional().describe("Example values for this slot"),
+      normalization: z.string().optional().describe("Normalization strategy")
+    });
+    AgentConfigSchema = z.object({
+      name: z.string().describe("Display name of the app"),
+      description: z.string().describe("Full description of what the app does"),
+      domain: z.string().describe("Domain category"),
+      llm: z.object({
+        provider: z.string().default("openai"),
+        models: z.object({
+          planning: z.string().default("gpt-4o-mini"),
+          extraction: z.string().default("gpt-4o-mini"),
+          synthesis: z.string().default("gpt-4o-mini"),
+          questionGeneration: z.string().default("gpt-4o-mini")
+        })
+      }),
+      prompts: z.object({
+        plannerSystemRole: z.string().describe("Role description for the planner"),
+        synthesisSystemRole: z.string().describe("Role description for synthesis"),
+        planningInstructions: z.string().describe("Instructions for planning"),
+        synthesisInstructions: z.string().describe("Instructions for answer synthesis"),
+        extractionInstructions: z.string().describe("Instructions for slot extraction")
+      }),
+      goals: z.array(GoalSchema).describe("Possible user intents/goals"),
+      messages: z.object({
+        allKBsFailed: z.string().describe("Message when KB access fails"),
+        noRelevantInfo: z.string().describe("Message when no relevant info found"),
+        synthesisError: z.string().describe("Message when synthesis fails")
+      }),
+      slots: z.array(SlotSchema).describe("Extraction slots for user queries"),
+      slotPriority: z.array(z.string()).describe("Priority order for slot filling"),
+      defaultKbId: z.string().describe("Default KB to use"),
+      citations: z.object({
+        format: z.string().default("brackets").describe("Citation format: brackets, footnotes, or inline"),
+        labelPrefix: z.string().default("S")
+      }),
+      behavior: z.object({
+        maxDisambiguationAttempts: z.number().default(3),
+        fallbackStrategy: z.string().default("use_first").describe("Fallback strategy: use_first, ask_user, or none"),
+        enablePlanModification: z.boolean().default(true)
+      }),
+      quickQuestions: z.array(z.string()).describe("Example questions for the UI")
+    });
+    EXCLUDED_PATHS = [
+      "node_modules",
+      ".next",
+      ".git",
+      "data",
+      ".env.local",
+      ".DS_Store",
+      "pnpm-lock.yaml",
+      "package-lock.json"
+    ];
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+init_config();
+init_colors();
+
+// src/utils/prompts.ts
+init_esm_shims();
+init_colors();
+function createReadline() {
+  return readline.createInterface({ input: stdin, output: stdout });
+}
+async function askQuestion(rl, question, defaultValue) {
+  const defaultHint = defaultValue ? colors.gray(` [${defaultValue}]`) : "";
+  const answer = await rl.question(`${colors.cyan(icons.pointer)} ${question}${defaultHint}: `);
+  return answer.trim() || defaultValue || "";
+}
+async function askConfirm(rl, question, defaultValue = false) {
+  const hint = defaultValue ? colors.gray(" [Y/n]") : colors.gray(" [y/N]");
+  const answer = await rl.question(`${colors.cyan(icons.pointer)} ${question}${hint}: `);
+  if (!answer.trim()) return defaultValue;
+  return /^y(es)?$/i.test(answer.trim());
+}
+async function askSelect(rl, question, options) {
+  console.log(`
+${colors.cyan(icons.pointer)} ${question}`);
+  for (const opt of options) {
+    console.log(menuOption(opt.key, opt.label, opt.description));
+  }
+  const answer = await rl.question(`
+${colors.cyan(icons.pointer)} Enter choice: `);
+  return answer.trim().toLowerCase();
+}
+
+// src/commands/ingest.ts
+init_esm_shims();
+init_colors();
+init_config();
+var ingestCommand = new Command("ingest").description("Ingest CSV data into Pinecone assistants").option("-o, --output <mode>", "Output mode: pinecone, local, or both", "pinecone").option("-d, --dir <path>", "Local output directory for ingested files").option("--dry-run", "Preview changes without making them", false).option("-i, --interactive", "Run in interactive mode", false).option("--verbose", "Show detailed output", false).action(async (options) => {
+  if (options.interactive) {
+    await runInteractive();
+  } else {
+    await runIngest(options);
+  }
+});
+async function runInteractive() {
+  printHeader("Data Ingestion", icons.database);
+  console.log(colors.gray("Ingest CSV data into Pinecone assistants with topic extraction.\n"));
+  const rl = createReadline();
+  try {
+    const dataDir = findDataDir();
+    if (!dataDir) {
+      printError("Data directory not found.");
+      printInfo("Make sure you have CSV files in a data/ directory.");
+      return;
+    }
+    const csvFiles = fs9.readdirSync(dataDir).filter((f) => f.endsWith(".csv"));
+    if (csvFiles.length === 0) {
+      printWarning("No CSV files found in data directory.");
+      return;
+    }
+    console.log(colors.white("Available CSV files:"));
+    printList(csvFiles.map((f) => `${f} ${colors.gray(`(${path10.join(dataDir, f)})`)}`));
+    const outputModeChoice = await askSelect(rl, "Where should the data be written?", [
+      { key: "1", label: "Pinecone", description: "Upload to Pinecone assistant (remote)" },
+      { key: "2", label: "Local", description: "Write markdown files to disk" },
+      { key: "3", label: "Both", description: "Pinecone + local files" }
+    ]);
+    const outputModeMap = {
+      "1": "pinecone",
+      "2": "local",
+      "3": "both"
+    };
+    const output2 = outputModeMap[outputModeChoice] || "pinecone";
+    let dir;
+    if (output2 === "local" || output2 === "both") {
+      const defaultDir = path10.join(dataDir, "ingested");
+      dir = await askQuestion(rl, "Local output directory", defaultDir);
+    }
+    const dryRun = await askConfirm(rl, "Dry run (preview without making changes)?", false);
+    const confirm = await askConfirm(rl, "Proceed with ingestion?", true);
+    if (!confirm) {
+      printInfo("Ingestion cancelled.");
+      return;
+    }
+    await runIngest({ output: output2, dir, dryRun, interactive: true, verbose: false });
+  } finally {
+    rl.close();
+  }
+}
+async function runIngest(options) {
+  const { output: output2, dir, dryRun, verbose } = options;
+  if (output2 === "pinecone" || output2 === "both") {
+    const { missing } = requireEnv(["PINECONE_API_KEY"]);
+    if (missing.length > 0) {
+      printError(`Missing required environment variables: ${missing.join(", ")}`);
+      printInfo("Set these in your .env.local file or environment.");
+      process.exit(1);
+    }
+  }
+  const dataDir = findDataDir();
+  if (!dataDir) {
+    printError("Data directory not found.");
+    process.exit(1);
+  }
+  const spinner = new Spinner("Preparing ingestion...", colors.cyan);
+  spinner.start();
+  try {
+    const ingestModule = await Promise.resolve().then(() => (init_ingest(), ingest_exports));
+    spinner.stop();
+    await ingestModule.ingestData({
+      outputMode: output2,
+      localOutputDir: dir,
+      dryRun,
+      verbose,
+      dataDir
+    });
+    if (!dryRun) {
+      printSuccess("Data ingestion completed successfully!");
+    } else {
+      printInfo("Dry run completed. No changes were made.");
+    }
+  } catch (error) {
+    spinner.fail("Ingestion failed");
+    printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/compose.ts
+init_esm_shims();
+init_colors();
+init_config();
+var composeCommand = new Command("compose").description("Build KB manifests interactively with AI").option("--kb-id <id>", "KB identifier (e.g., kb_shipping)").option("--domain <domain>", "Domain name (e.g., returns, warranty)").option("--description <desc>", "Short description of the KB").option("--assistant <name>", "Pinecone assistant name").option("--source <path>", "Path to source CSV data (optional)").option("-s, --storage <mode>", "Storage mode: local, pinecone, or both", "local").option("--dry-run", "Preview manifest without saving", false).option("-i, --interactive", "Run in interactive mode", false).action(async (options) => {
+  if (options.interactive || !options.kbId) {
+    await runInteractive2(options);
+  } else {
+    await runCompose(options);
+  }
+});
+async function runInteractive2(initialOptions = {}) {
+  printHeader("Composition Builder", icons.tools);
+  console.log(colors.gray("Build KB manifests from scratch or CSV data.\n"));
+  const rl = createReadline();
+  try {
+    const kbId = initialOptions.kbId || await askQuestion(rl, "KB ID (e.g., kb_shipping)");
+    if (!kbId) {
+      printWarning("KB ID is required.");
+      return;
+    }
+    const domain = initialOptions.domain || await askQuestion(rl, "Domain (e.g., returns, warranty)");
+    const description = initialOptions.description || await askQuestion(rl, "Short description");
+    const assistant = initialOptions.assistant || await askQuestion(rl, "Assistant name", kbId.replace(/_/g, "-"));
+    const source = initialOptions.source || await askQuestion(
+      rl,
+      "Path to source data CSV (optional, press Enter to skip)"
+    );
+    const storageModeChoice = await askSelect(rl, "Where should the manifest be saved?", [
+      { key: "1", label: "Local", description: "Save as JSON file in composition/manifests/" },
+      { key: "2", label: "Pinecone", description: "Save to Pinecone assistant metadata" },
+      { key: "3", label: "Both", description: "Save locally and to Pinecone" }
+    ]);
+    const storageModeMap = {
+      "1": "local",
+      "2": "pinecone",
+      "3": "both"
+    };
+    const storage = storageModeMap[storageModeChoice] || "local";
+    const dryRun = await askConfirm(rl, "Dry run (preview without saving)?", false);
+    await runCompose({
+      kbId,
+      domain,
+      description,
+      assistant,
+      source: source || void 0,
+      storage,
+      dryRun,
+      interactive: true
+    });
+  } finally {
+    rl.close();
+  }
+}
+async function runCompose(options) {
+  const { kbId, domain, description, assistant, source, storage, dryRun } = options;
+  if (!kbId) {
+    printError("KB ID is required. Use --kb-id or run in interactive mode.");
+    process.exit(1);
+  }
+  const { missing } = requireEnv(["OPENAI_API_KEY"]);
+  if (missing.length > 0) {
+    printWarning(`Missing environment variables: ${missing.join(", ")}`);
+    printInfo("AI-assisted composition may not work without these.");
+  }
+  if (storage === "pinecone" || storage === "both") {
+    const { missing: pineconeMissing } = requireEnv(["PINECONE_API_KEY"]);
+    if (pineconeMissing.length > 0) {
+      printError("PINECONE_API_KEY is required for Pinecone storage.");
+      process.exit(1);
+    }
+  }
+  const spinner = new Spinner("Generating manifest with AI...", colors.magenta);
+  spinner.start();
+  try {
+    const composeModule = await Promise.resolve().then(() => (init_compose(), compose_exports));
+    spinner.stop();
+    const result = await composeModule.buildComposition({
+      kbId,
+      domain: domain || "",
+      description: description || "",
+      assistantName: assistant || kbId.replace(/_/g, "-"),
+      sourcePath: source,
+      storageMode: storage,
+      dryRun
+    });
+    if (result.saved) {
+      if (result.savedToLocal) {
+        printSuccess(`Manifest saved locally to ${result.outputPath}`);
+      }
+      if (result.savedToPinecone) {
+        printSuccess("Manifest saved to Pinecone assistant");
+      }
+    } else if (dryRun) {
+      printInfo("Dry run completed. No file was written.");
+    }
+  } catch (error) {
+    spinner.fail("Manifest generation failed");
+    printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/introspect.ts
+init_esm_shims();
+init_colors();
+init_config();
+function parseStorageMode(value) {
+  const normalized = value.toLowerCase().trim();
+  if (normalized === "local" || normalized === "pinecone" || normalized === "both") {
+    return normalized;
+  }
+  throw new InvalidArgumentError(
+    `Invalid storage mode "${value}". Use one of: local, pinecone, both.`
+  );
+}
+function parsePositiveInt(value, optionName) {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new InvalidArgumentError(`${optionName} must be a positive integer.`);
+  }
+  return parsed;
+}
+var introspectCommand = new Command("introspect").description("Generate manifest from existing Pinecone assistant").option("-a, --assistant <name>", "Pinecone assistant name").option("--kb-id <id>", "KB identifier (defaults to assistant name)").option("--domain <domain>", "Domain name (will be inferred if not provided)").option("-s, --storage <mode>", "Storage mode: local, pinecone, or both", parseStorageMode, "local").option("--dry-run", "Preview manifest without saving", false).option("--verbose", "Show detailed Q&A during introspection", false).option("-i, --interactive", "Run in interactive mode", false).option("--max-depth <n>", "Category drilling depth", (v) => parsePositiveInt(v, "--max-depth")).option("--max-questions <n>", "Total question budget", (v) => parsePositiveInt(v, "--max-questions")).option("--max-branch <n>", "Max expansions per discovered item", (v) => parsePositiveInt(v, "--max-branch")).option("--max-retries <n>", "Retries for generic responses", (v) => parsePositiveInt(v, "--max-retries")).option("--llm-model <id>", "OpenAI model for introspection (overrides KBS_INTROSPECTION_MODEL)").action(async (options) => {
+  if (options.interactive || !options.assistant) {
+    await runInteractive3(options);
+  } else {
+    await runIntrospect(options);
+  }
+});
+async function runInteractive3(initialOptions = {}) {
+  printHeader("Manifest Introspector", icons.search);
+  console.log(colors.gray("Generate manifests by introspecting Pinecone assistants.\n"));
+  const rl = createReadline();
+  try {
+    const assistant = initialOptions.assistant || await askQuestion(rl, "Pinecone assistant name");
+    if (!assistant) {
+      printWarning("Assistant name is required.");
+      return;
+    }
+    const kbId = initialOptions.kbId || await askQuestion(rl, "KB ID", assistant);
+    const domain = initialOptions.domain || await askQuestion(rl, "Domain (press Enter to infer)");
+    const storageModeChoice = await askSelect(rl, "Where should the manifest be saved?", [
+      { key: "1", label: "Local", description: "Save as JSON file in composition/manifests/" },
+      { key: "2", label: "Pinecone", description: "Save to Pinecone assistant metadata" },
+      { key: "3", label: "Both", description: "Save locally and to Pinecone" }
+    ]);
+    const storageModeMap = {
+      "1": "local",
+      "2": "pinecone",
+      "3": "both"
+    };
+    const storage = storageModeMap[storageModeChoice] || "local";
+    const dryRun = await askConfirm(rl, "Dry run (preview without saving)?", false);
+    const verbose = await askConfirm(rl, "Verbose output (show Q&A)?", false);
+    console.log("");
+    printInfo("Starting introspection. This may take a few minutes...");
+    await runIntrospect({
+      assistant,
+      kbId,
+      domain: domain || void 0,
+      storage,
+      dryRun,
+      verbose,
+      interactive: true
+    });
+  } finally {
+    rl.close();
+  }
+}
+async function runIntrospect(options) {
+  const { assistant, kbId, domain, storage, dryRun, verbose, maxDepth, maxQuestions, maxBranch, maxRetries, llmModel } = options;
+  if (!assistant) {
+    printError("Assistant name is required. Use --assistant or run in interactive mode.");
+    process.exit(1);
+  }
+  const { missing } = requireEnv(["PINECONE_API_KEY", "OPENAI_API_KEY"]);
+  if (missing.length > 0) {
+    printError(`Missing required environment variables: ${missing.join(", ")}`);
+    process.exit(1);
+  }
+  if (dryRun) {
+    printInfo("Dry run enabled: introspection still queries Pinecone and OpenAI, but it does not write outputs.");
+  } else {
+    const saveTargets = storage === "both" ? "local manifest file and Pinecone assistant metadata" : storage === "local" ? "a local manifest file" : "Pinecone assistant metadata";
+    printInfo(`Save target: ${saveTargets}.`);
+  }
+  const spinner = new Spinner("Introspecting assistant...", colors.blue);
+  if (!verbose) {
+    spinner.start();
+  }
+  try {
+    const introspectModule = await Promise.resolve().then(() => (init_introspect(), introspect_exports));
+    if (!verbose) {
+      spinner.stop();
+    }
+    const result = await introspectModule.introspectAssistant({
+      assistantName: assistant,
+      kbId: kbId || assistant,
+      domain,
+      storageMode: storage,
+      dryRun,
+      verbose,
+      maxDepth,
+      maxQuestions,
+      maxBranch,
+      maxRetries,
+      llmModel
+    });
+    if (result.saved) {
+      if (result.savedToLocal) {
+        printSuccess(`Manifest saved locally to ${result.outputPath}`);
+      }
+      if (result.savedToPinecone) {
+        printSuccess("Manifest saved to Pinecone assistant");
+      }
+    } else if (dryRun) {
+      printInfo("Dry run completed. No writes were performed.");
+      if (result.wouldSaveToLocal && result.outputPath) {
+        printInfo(`Would save local manifest to ${result.outputPath}`);
+      }
+      if (result.wouldSaveToPinecone) {
+        printInfo("Would save manifest to Pinecone assistant metadata");
+      }
+    }
+  } catch (error) {
+    if (!verbose) {
+      spinner.fail("Introspection failed");
+    }
+    printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/validate.ts
+init_esm_shims();
+init_colors();
+init_config();
+var validateCommand = new Command("validate").description("Validate CSV data against KB definitions").option("-p, --path <path>", "Path to specific CSV file or directory").option("--json", "Output results as JSON", false).option("-i, --interactive", "Run in interactive mode", false).action(async (options) => {
+  if (options.interactive) {
+    await runInteractive4();
+  } else {
+    await runValidate(options);
+  }
+});
+async function runInteractive4() {
+  printHeader("Data Validator", icons.check);
+  console.log(colors.gray("Validate CSV data against KB manifest definitions.\n"));
+  const rl = createReadline();
+  try {
+    const dataDir = findDataDir();
+    if (dataDir) {
+      console.log(colors.gray(`Found data directory: ${dataDir}
+`));
+    }
+    const confirm = await askConfirm(rl, "Run validation?", true);
+    if (!confirm) {
+      return;
+    }
+    await runValidate({ json: false, interactive: true });
+  } finally {
+    rl.close();
+  }
+}
+async function runValidate(options) {
+  const { path: dataPath, json } = options;
+  try {
+    const validateModule = await Promise.resolve().then(() => (init_validate(), validate_exports));
+    const result = await validateModule.validateData({ path: dataPath });
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log("");
+    divider();
+    console.log(colors.boldWhite("Validation Summary"));
+    divider();
+    for (const kb of result.results) {
+      const statusIcon = kb.valid ? colors.green(icons.success) : colors.red(icons.error);
+      console.log(`${statusIcon} ${colors.white(kb.name)}: ${kb.records} records`);
+      if (kb.issues.length > 0) {
+        for (const issue of kb.issues) {
+          console.log(`   ${colors.yellow(icons.warning)} ${issue}`);
+        }
+      }
+    }
+    console.log("");
+    if (result.allValid) {
+      printSuccess("All data validates successfully!");
+    } else {
+      printWarning("Some validation issues found. Review output above.");
+      process.exit(1);
+    }
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/topics.ts
+init_esm_shims();
+init_colors();
+var topicsCommand = new Command("topics").description("Test topic extraction on files").argument("[paths...]", "Files or directories to process").option("-m, --mode <mode>", "Extraction mode: classic, slm, or hybrid").option("-n, --top-n <n>", "Number of topics per document", "5").option("--verbose", "Show document previews", false).option("--json", "Output results as JSON", false).option("-i, --interactive", "Run in interactive mode", false).action(async (paths, options) => {
+  const fullOptions = { ...options, paths, topN: parseInt(options.topN, 10) || 5 };
+  if (fullOptions.interactive || paths.length === 0) {
+    await runInteractive5(fullOptions);
+  } else {
+    await runTopics(fullOptions);
+  }
+});
+async function runInteractive5(initialOptions = {}) {
+  printHeader("Topic Extraction Tester", icons.sparkles);
+  console.log(colors.gray("Test topic extraction on files without full ingestion.\n"));
+  const rl = createReadline();
+  try {
+    const inputPath = await askQuestion(rl, "File or directory path");
+    if (!inputPath) {
+      printWarning("Path is required.");
+      return;
+    }
+    const modeChoice = await askSelect(rl, "Select extraction mode:", [
+      { key: "1", label: "Classic (TF-IDF)", description: "Fast, keyword-based extraction" },
+      { key: "2", label: "SLM (LLM)", description: "AI-powered semantic extraction" },
+      { key: "3", label: "Hybrid", description: "Both methods combined" },
+      { key: "4", label: "Default", description: "Use config settings" }
+    ]);
+    const modeMap = {
+      "1": "classic",
+      "2": "slm",
+      "3": "hybrid",
+      "4": void 0
+    };
+    const mode = modeMap[modeChoice];
+    const topNStr = await askQuestion(rl, "Number of topics per document", "5");
+    const topN = parseInt(topNStr, 10) || 5;
+    const verbose = await askConfirm(rl, "Show document previews?", false);
+    const json = await askConfirm(rl, "Output as JSON?", false);
+    await runTopics({
+      paths: [inputPath],
+      mode,
+      topN,
+      verbose,
+      json,
+      interactive: true
+    });
+  } finally {
+    rl.close();
+  }
+}
+async function runTopics(options) {
+  const { paths, mode, topN, verbose, json } = options;
+  if (paths.length === 0) {
+    printError("At least one path is required.");
+    process.exit(1);
+  }
+  try {
+    const topicsModule = await Promise.resolve().then(() => (init_topics(), topics_exports));
+    await topicsModule.testTopics({
+      paths,
+      mode,
+      topN,
+      verbose,
+      json
+    });
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/sync.ts
+init_esm_shims();
+init_colors();
+init_config();
+var syncCommand = new Command("sync").description("Sync manifests between local files and Pinecone").option("-d, --direction <dir>", "Sync direction: toLocal, toPinecone, or both").option("--dry-run", "Preview changes without making them", false).option("-i, --interactive", "Run in interactive mode", false).action(async (options) => {
+  if (options.interactive || !options.direction) {
+    await runInteractive6(options);
+  } else {
+    await runSync(options);
+  }
+});
+async function runInteractive6(initialOptions = {}) {
+  printHeader("Manifest Sync", icons.gear);
+  console.log(colors.gray("Sync manifests between local files and Pinecone assistant metadata.\n"));
+  const { missing } = requireEnv(["PINECONE_API_KEY"]);
+  if (missing.length > 0) {
+    printError(`Missing required environment variables: ${missing.join(", ")}`);
+    return;
+  }
+  const rl = createReadline();
+  try {
+    const syncModule = await Promise.resolve().then(() => (init_sync(), sync_exports));
+    const manifests = await syncModule.listManifests();
+    console.log(colors.white("Current manifests:"));
+    console.log(
+      `  ${colors.cyan("Local:")} ${manifests.local.length > 0 ? manifests.local.map((m) => m.id).join(", ") : colors.gray("(none)")}`
+    );
+    console.log(
+      `  ${colors.blue("Pinecone:")} ${manifests.pinecone.length > 0 ? manifests.pinecone.map((m) => m.id).join(", ") : colors.gray("(none)")}`
+    );
+    const syncChoice = await askSelect(rl, "What would you like to do?", [
+      { key: "1", label: "Download from Pinecone", description: "Save Pinecone manifests locally" },
+      { key: "2", label: "Upload to Pinecone", description: "Save local manifests to Pinecone" },
+      { key: "3", label: "Sync both ways", description: "Sync all manifests in both directions" },
+      { key: "4", label: "Cancel", description: "Go back" }
+    ]);
+    if (syncChoice === "4") {
+      printInfo("Cancelled.");
+      return;
+    }
+    const directionMap = {
+      "1": "toLocal",
+      "2": "toPinecone",
+      "3": "both"
+    };
+    const direction = directionMap[syncChoice];
+    if (!direction) {
+      return;
+    }
+    const dryRun = initialOptions.dryRun || await askConfirm(rl, "Dry run (preview without changes)?", false);
+    const confirm = await askConfirm(rl, "Proceed with sync?", true);
+    if (!confirm) {
+      printInfo("Cancelled.");
+      return;
+    }
+    await runSync({ direction, dryRun, interactive: true });
+  } finally {
+    rl.close();
+  }
+}
+async function runSync(options) {
+  const { direction, dryRun } = options;
+  if (!direction) {
+    printError("Sync direction is required. Use --direction or run in interactive mode.");
+    process.exit(1);
+  }
+  const { missing } = requireEnv(["PINECONE_API_KEY"]);
+  if (missing.length > 0) {
+    printError(`Missing required environment variables: ${missing.join(", ")}`);
+    process.exit(1);
+  }
+  try {
+    const syncModule = await Promise.resolve().then(() => (init_sync(), sync_exports));
+    const result = await syncModule.syncManifests(direction, { dryRun });
+    if (dryRun) {
+      printInfo(`Would sync ${result.synced} manifest(s).`);
+    } else if (result.synced > 0) {
+      printSuccess(`Synced ${result.synced} manifest(s)`);
+    } else {
+      printInfo("No manifests to sync.");
+    }
+    if (result.errors.length > 0) {
+      for (const error of result.errors) {
+        printError(error);
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/generate.ts
+init_esm_shims();
+init_colors();
+init_config();
+var generateCommand = new Command("generate").description("Scaffold a new KAT app with guided questions").option("-n, --name <name>", "App name").option("-d, --description <desc>", "App description").option("--domain <domain>", "Domain (e.g., support, education, healthcare)").option("-t, --template <template>", "App template: native or vercel-ai", "native").option("-o, --output <path>", "Output directory", ".").option("-i, --interactive", "Run in interactive mode", false).action(async (options) => {
+  if (options.interactive || !options.name) {
+    await runInteractive7(options);
+  } else {
+    await runGenerate(options);
+  }
+});
+async function runInteractive7(initialOptions = {}) {
+  printHeader("App Generator", icons.rocket);
+  console.log(colors.gray("Create a new KAT-powered Next.js app with guided setup.\n"));
+  const rl = createReadline();
+  try {
+    const templateChoice = await askSelect(rl, "Which app template would you like to use?", [
+      { key: "1", label: "Native Next.js", description: "Uses runAgent() with JSON responses" },
+      { key: "2", label: "Vercel AI SDK", description: "Uses runAgentStreaming() with useChat hook" }
+    ]);
+    const template = templateChoice === "2" ? "vercel-ai" : "native";
+    console.log("\n" + colors.boldWhite("Basic Information"));
+    const name = initialOptions.name || await askQuestion(rl, "App name");
+    if (!name) {
+      printWarning("App name is required.");
+      return;
+    }
+    const description = initialOptions.description || await askQuestion(
+      rl,
+      "App description",
+      `A ${name} assistant powered by KAT`
+    );
+    const domain = initialOptions.domain || await askQuestion(
+      rl,
+      "Domain (e.g., support, education, healthcare)",
+      "general"
+    );
+    const output2 = initialOptions.output || await askQuestion(
+      rl,
+      "Output directory",
+      `./${name.toLowerCase().replace(/\s+/g, "-")}`
+    );
+    console.log("\n" + colors.boldWhite("Summary:"));
+    console.log(`  ${colors.cyan("Template:")} ${template === "vercel-ai" ? "Vercel AI SDK" : "Native Next.js"}`);
+    console.log(`  ${colors.cyan("Name:")} ${name}`);
+    console.log(`  ${colors.cyan("Description:")} ${description}`);
+    console.log(`  ${colors.cyan("Domain:")} ${domain}`);
+    console.log(`  ${colors.cyan("Output:")} ${output2}`);
+    const proceed = await askConfirm(rl, "\nProceed with generation?", true);
+    if (!proceed) {
+      printInfo("Generation cancelled.");
+      return;
+    }
+    await runGenerate({
+      name,
+      description,
+      domain,
+      template,
+      output: output2,
+      interactive: true
+    });
+  } finally {
+    rl.close();
+  }
+}
+async function runGenerate(options) {
+  const { name, description, domain, template, output: output2 } = options;
+  if (!name) {
+    printError("App name is required. Use --name or run in interactive mode.");
+    process.exit(1);
+  }
+  const { missing } = requireEnv(["OPENAI_API_KEY"]);
+  if (missing.length > 0) {
+    printWarning(`Missing environment variables: ${missing.join(", ")}`);
+    printInfo("LLM-assisted generation may not work without these.");
+  }
+  const spinner = new Spinner("Generating app...", colors.magenta);
+  spinner.start();
+  try {
+    const generateModule = await Promise.resolve().then(() => (init_generate(), generate_exports));
+    spinner.stop();
+    const result = await generateModule.generateApp({
+      name,
+      description: description || `A ${name} assistant`,
+      domain: domain || "general",
+      template: template || "native",
+      outputDir: output2 || "."
+    });
+    if (result.success) {
+      console.log("");
+      printSuccess(`App generated successfully at ${colors.cyan(result.outputPath)}`);
+      console.log("");
+      console.log(colors.boldWhite("Next steps:"));
+      console.log(`  ${colors.gray("1.")} cd ${result.outputPath}`);
+      console.log(`  ${colors.gray("2.")} npm install`);
+      console.log(`  ${colors.gray("3.")} cp .env.example .env.local  ${colors.gray("# Add your API keys")}`);
+      console.log(`  ${colors.gray("4.")} npm run dev`);
+      console.log("");
+      printInfo("Edit agent.config.json to customize your app behavior.");
+    }
+  } catch (error) {
+    spinner.fail("App generation failed");
+    printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+// src/commands/eval.ts
+init_esm_shims();
+init_colors();
+async function loadEvalModule() {
+  try {
+    return await import('@kat/eval');
+  } catch (error) {
+    throw new Error(
+      "Failed to load @kat/eval. Make sure it is installed:\n  npm install @kat/eval"
+    );
+  }
+}
+var DEFAULT_BASELINE_SCENARIOS_PATH = "eval/baseline/naive-rag-baseline.json";
+var evalCommand = new Command().name("eval").description("Evaluate RAG system quality across introspection, retrieval, and agent layers").option("-l, --layer <layer>", "Eval layer: introspection, retrieval, agent, all", "all").option("-a, --assistant <name>", "Pinecone assistant name (required for introspection/retrieval)").option("-s, --scenarios <path>", "Path to scenarios JSON file").option("-b, --baseline", `Load canonical baseline fixtures from ./${DEFAULT_BASELINE_SCENARIOS_PATH}`).option("-e, --endpoint <url>", "Agent API endpoint (required for agent layer)").option("-o, --output <format>", "Output format: console, json", "console").option("-v, --verbose", "Show detailed output").option("-i, --interactive", "Run in interactive mode").action(async (options) => {
+  try {
+    await runEval(options);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+});
+async function runEval(options) {
+  const { layer, assistant, scenarios, baseline, endpoint, output: output2, verbose } = options;
+  if ((layer === "introspection" || layer === "retrieval" || layer === "all") && !assistant) {
+    throw new Error("--assistant is required for introspection and retrieval eval");
+  }
+  if (baseline && scenarios) {
+    throw new Error("--baseline and --scenarios cannot be used together");
+  }
+  const evalModule = await loadEvalModule();
+  const scenarioPath = resolveScenarioPath({ scenarios, baseline });
+  let scenarioData = null;
+  if (scenarioPath) {
+    scenarioData = await loadScenarioBundle(scenarioPath);
+  }
+  if (baseline && output2 === "console" && scenarioPath) {
+    console.log(colors.gray(`Using baseline fixtures: ${scenarioPath}`));
+  }
+  const hasAgentScenarios = Array.isArray(scenarioData?.scenarios) && scenarioData.scenarios.length > 0;
+  if (layer === "agent" && !endpoint) {
+    throw new Error("--endpoint is required for agent eval");
+  }
+  if (layer === "all" && hasAgentScenarios && !endpoint) {
+    throw new Error(
+      "--endpoint is required when running all layers with agent scenarios (use --layer introspection or --layer retrieval to skip agent eval)"
+    );
+  }
+  const results = [];
+  if (layer === "introspection" || layer === "all") {
+    if (output2 === "console") {
+      console.log("\n" + colors.cyan("\u2501".repeat(60)));
+      console.log(colors.bold("Layer 1: Introspection Eval"));
+      console.log(colors.cyan("\u2501".repeat(60)));
+    }
+    const manifestPath = resolve(process.cwd(), `composition/manifests/${assistant}.json`);
+    let manifest;
+    try {
+      const content = await readFile(manifestPath, "utf-8");
+      manifest = JSON.parse(content);
+    } catch {
+      if (output2 === "console") {
+        console.log(colors.yellow(`\u26A0 No manifest found at ${manifestPath}`));
+        console.log(colors.gray('  Run "kat introspect --assistant ' + assistant + '" first'));
+      }
+      manifest = { id: assistant, assistantName: assistant };
+    }
+    const config2 = {
+      assistantName: assistant,
+      manifest,
+      groundTruth: scenarioData?.groundTruth || [],
+      verbose
+    };
+    const result = await evalModule.evaluateIntrospection(config2);
+    results.push({ layer: "introspection", result });
+    if (output2 === "console") {
+      printEvalResult("Introspection", result);
+    }
+  }
+  if (layer === "retrieval" || layer === "all") {
+    if (output2 === "console") {
+      console.log("\n" + colors.cyan("\u2501".repeat(60)));
+      console.log(colors.bold("Layer 2: Retrieval Eval"));
+      console.log(colors.cyan("\u2501".repeat(60)));
+    }
+    const queries = scenarioData?.queries || [
+      { query: "What topics can you help with?", expectedTopics: [] }
+    ];
+    const config2 = {
+      assistantName: assistant,
+      queries,
+      verbose
+    };
+    const result = await evalModule.evaluateRetrieval(config2);
+    results.push({ layer: "retrieval", result });
+    if (output2 === "console") {
+      printEvalResult("Retrieval", result);
+    }
+  }
+  if (layer === "agent" || layer === "all") {
+    const agentScenarios = scenarioData?.scenarios ? [...scenarioData.scenarios] : [];
+    if (layer === "agent" || endpoint || agentScenarios.length > 0) {
+      if (output2 === "console") {
+        console.log("\n" + colors.cyan("\u2501".repeat(60)));
+        console.log(colors.bold("Layer 3: Agent Eval"));
+        console.log(colors.cyan("\u2501".repeat(60)));
+      }
+      if (agentScenarios.length === 0 && endpoint) {
+        agentScenarios.push({
+          name: "basic-test",
+          initialQuery: "Hello, can you help me?",
+          expectedOutcome: "answer",
+          evaluation: { rubric: "Agent should provide a helpful response." }
+        });
+      }
+      const config2 = {
+        agentEndpoint: endpoint,
+        scenarios: agentScenarios,
+        verbose
+      };
+      const result = await evalModule.evaluateAgent(config2);
+      results.push({ layer: "agent", result });
+      if (output2 === "console") {
+        printEvalResult("Agent", result);
+      }
+    } else if (output2 === "console") {
+      console.log(colors.yellow("\n\u26A0 Skipping agent eval (no endpoint or scenarios provided)"));
+    }
+  }
+  if (output2 === "json") {
+    const jsonOutput = results.length === 1 ? results[0].result : results;
+    console.log(JSON.stringify(jsonOutput, null, 2));
+  }
+  if (output2 === "console") {
+    printSummary(results);
+  }
+}
+function printEvalResult(layerName, result) {
+  const status = result.passed ? colors.green("\u2713 PASSED") : colors.red("\u2717 FAILED");
+  const score = result.overallScore;
+  console.log(`
+${status} - Overall Score: ${formatScore(score)}/100`);
+  console.log(colors.gray(`Duration: ${result.duration}ms`));
+  console.log("\nScores:");
+  for (const [name, value] of Object.entries(result.scores)) {
+    const formattedName = name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+    const bar = createProgressBar(value, 20);
+    console.log(`  ${formattedName.padEnd(18)} ${bar} ${formatScore(value)}/100`);
+  }
+  if (result.evidence && result.evidence.length > 0) {
+    console.log("\nKey Findings:");
+    for (const evidence of result.evidence.slice(0, 4)) {
+      const icon = evidence.score >= 70 ? colors.green("\u2713") : colors.yellow("\u26A0");
+      console.log(`  ${icon} ${evidence.reasoning}`);
+    }
+  }
+}
+function printSummary(results) {
+  console.log("\n" + colors.cyan("\u2550".repeat(60)));
+  console.log(colors.bold("EVAL SUMMARY"));
+  console.log(colors.cyan("\u2550".repeat(60)));
+  const allPassed = results.every((r) => r.result.passed);
+  const avgScore = results.reduce((sum, r) => sum + r.result.overallScore, 0) / results.length;
+  console.log("\n" + drawBox([
+    `Overall: ${allPassed ? colors.green("PASSED") : colors.red("FAILED")}`,
+    `Average Score: ${formatScore(avgScore)}/100`,
+    "",
+    ...results.map((r) => {
+      const icon = r.result.passed ? "\u2713" : "\u2717";
+      const color = r.result.passed ? colors.green : colors.red;
+      return `${color(icon)} ${r.layer.charAt(0).toUpperCase() + r.layer.slice(1)}: ${r.result.overallScore}/100`;
+    })
+  ], { borderColor: allPassed ? colors.green : colors.red, padding: 1 }));
+  console.log("");
+}
+function formatScore(score) {
+  if (score >= 80) return colors.green(String(Math.round(score)));
+  if (score >= 60) return colors.yellow(String(Math.round(score)));
+  return colors.red(String(Math.round(score)));
+}
+function createProgressBar(value, width) {
+  const filled = Math.round(value / 100 * width);
+  const empty = width - filled;
+  const filledChar = value >= 70 ? colors.green("\u2588") : value >= 50 ? colors.yellow("\u2588") : colors.red("\u2588");
+  const emptyChar = colors.gray("\u2591");
+  return "[" + filledChar.repeat(filled) + emptyChar.repeat(empty) + "]";
+}
+function resolveScenarioPath(options) {
+  if (options.scenarios) {
+    return resolve(process.cwd(), options.scenarios);
+  }
+  if (options.baseline) {
+    return resolve(process.cwd(), DEFAULT_BASELINE_SCENARIOS_PATH);
+  }
+  return null;
+}
+async function loadScenarioBundle(scenarioPath) {
+  try {
+    const content = await readFile(scenarioPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Scenario JSON must be an object");
+    }
+    return parsed;
+  } catch (error) {
+    throw new Error(`Failed to load scenarios from ${scenarioPath}: ${error}`);
+  }
+}
+
+// src/index.ts
+loadEnv();
+var program = new Command();
+program.name("kat").description("Knowledge Base Tools CLI - Manage Pinecone knowledge bases").version(getVersion(), "-v, --version", "Display version number").option("--no-color", "Disable colored output").option("--verbose", "Enable verbose output").hook("preAction", (thisCommand) => {
+  if (thisCommand.opts().noColor) {
+    process.env.NO_COLOR = "1";
+  }
+  if (thisCommand.opts().verbose) {
+    process.env.KAT_VERBOSE = "1";
+  }
+});
+program.addCommand(ingestCommand);
+program.addCommand(composeCommand);
+program.addCommand(introspectCommand);
+program.addCommand(validateCommand);
+program.addCommand(topicsCommand);
+program.addCommand(syncCommand);
+program.addCommand(generateCommand);
+program.addCommand(evalCommand);
+program.action(async () => {
+  await runInteractiveMode();
+});
+async function runInteractiveMode() {
+  printBanner();
+  console.log(
+    drawBox(
+      [
+        colors.white("Welcome to the KB Tools CLI!"),
+        "",
+        colors.gray("This tool helps you manage your knowledge bases:"),
+        `  ${colors.cyan("\u2022")} Ingest data into Pinecone`,
+        `  ${colors.cyan("\u2022")} Build and introspect manifests`,
+        `  ${colors.cyan("\u2022")} Validate data and test topics`
+      ],
+      { borderColor: colors.cyan, padding: 2 }
+    )
+  );
+  const rl = createReadline();
+  try {
+    await showMainMenu(rl);
+  } finally {
+    rl.close();
+  }
+}
+var MENU_COMMANDS = [
+  { key: "1", name: "Generate App", description: "Scaffold a new KAT app", icon: "\u{1F680}", command: "generate" },
+  { key: "2", name: "Ingest Data", description: "Ingest CSV data into Pinecone", icon: "\u{1F5C3}", command: "ingest" },
+  { key: "3", name: "Compose Manifest", description: "Build KB manifests with AI", icon: "\u{1F527}", command: "compose" },
+  { key: "4", name: "Introspect Assistant", description: "Generate manifest from Pinecone", icon: "\u{1F50D}", command: "introspect" },
+  { key: "5", name: "Eval Quality", description: "Evaluate RAG system quality", icon: "\u{1F4CA}", command: "eval" },
+  { key: "6", name: "Validate Data", description: "Validate CSV against definitions", icon: "\u2713", command: "validate" },
+  { key: "7", name: "Test Topics", description: "Test topic extraction", icon: "\u2728", command: "topics" },
+  { key: "8", name: "Sync Manifests", description: "Sync manifests local \u2194 Pinecone", icon: "\u2699", command: "sync" }
+];
+async function showMainMenu(rl) {
+  const options = [
+    ...MENU_COMMANDS.map((cmd) => ({
+      key: cmd.key,
+      label: `${cmd.icon} ${cmd.name}`,
+      description: cmd.description
+    })),
+    { key: "h", label: "? Help", description: "Show help information" },
+    { key: "q", label: "\u2717 Quit", description: "Exit the CLI" }
+  ];
+  const choice = await askSelect(rl, "What would you like to do?", options);
+  await handleMenuChoice(choice, rl);
+}
+async function handleMenuChoice(choice, rl) {
+  const keyToCommand = {
+    "1": "generate",
+    "2": "ingest",
+    "3": "compose",
+    "4": "introspect",
+    "5": "eval",
+    "6": "validate",
+    "7": "topics",
+    "8": "sync",
+    "h": "help",
+    "q": "quit",
+    // Also accept command names directly
+    generate: "generate",
+    ingest: "ingest",
+    compose: "compose",
+    introspect: "introspect",
+    eval: "eval",
+    validate: "validate",
+    topics: "topics",
+    sync: "sync",
+    help: "help",
+    quit: "quit",
+    exit: "quit"
+  };
+  const command = keyToCommand[choice.toLowerCase()] || choice;
+  if (command === "quit") {
+    console.log("\n" + colors.gray("Goodbye! \u{1F44B}") + "\n");
+    process.exit(0);
+  }
+  if (command === "help") {
+    program.outputHelp();
+    return showMainMenu(rl);
+  }
+  const menuCmd = MENU_COMMANDS.find((c) => c.command === command);
+  if (menuCmd) {
+    console.log("");
+    try {
+      await program.parseAsync([process.argv[0], process.argv[1], menuCmd.command, "--interactive"]);
+    } catch (error) {
+      printError(error instanceof Error ? error.message : String(error));
+    }
+    console.log("");
+    const continueChoice = await askConfirm(rl, "Return to main menu?", true);
+    if (continueChoice) {
+      return showMainMenu(rl);
+    } else {
+      console.log("\n" + colors.gray("Goodbye! \u{1F44B}") + "\n");
+      process.exit(0);
+    }
+  } else {
+    printError(`Unknown option: ${choice}`);
+    return showMainMenu(rl);
+  }
+}
+program.parse();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map