@kitnai/cli 0.1.35 → 0.1.36

package/dist/index.js

@@ -282,8 +282,8 @@ var init_config = __esm({
 // src/installers/tsconfig-patcher.ts
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { join as join4 } from "path";
-function stripJsonc(text3) {
-  return text3.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([}\]])/g, "$1");
+function stripJsonc(text4) {
+  return text4.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/,\s*([}\]])/g, "$1");
 }
 function patchTsconfig(tsconfigContent, paths, removePrefixes) {
   const config2 = JSON.parse(stripJsonc(tsconfigContent));
@@ -423,7 +423,7 @@ async function resolveDependencies(names, fetchItem) {
   const visited = /* @__PURE__ */ new Set();
   const items = /* @__PURE__ */ new Map();
   const edges = [];
-  async function resolve(name) {
+  async function resolve2(name) {
     if (visited.has(name)) return;
     visited.add(name);
     const item = await fetchItem(name);
@@ -431,11 +431,11 @@ async function resolveDependencies(names, fetchItem) {
     const deps = item.registryDependencies ?? [];
     for (const dep of deps) {
       edges.push([dep, name]);
-      await resolve(dep);
+      await resolve2(dep);
     }
   }
   for (const name of names) {
-    await resolve(name);
+    await resolve2(name);
   }
   return topologicalSort(items, edges);
 }
@@ -3448,14 +3448,61 @@ var init_registry = __esm({
 // src/commands/chat.ts
 var chat_exports = {};
 __export(chat_exports, {
-  buildRequestPayload: () => buildRequestPayload,
+  applyCompaction: () => applyCompaction,
+  buildServicePayload: () => buildServicePayload,
   chatCommand: () => chatCommand,
   fetchGlobalRegistries: () => fetchGlobalRegistries,
+  formatElapsed: () => formatElapsed,
   formatPlan: () => formatPlan,
-  resolveServiceUrl: () => resolveServiceUrl
+  formatSessionStats: () => formatSessionStats,
+  formatStepLabel: () => formatStepLabel,
+  formatTokens: () => formatTokens,
+  handleAskUser: () => handleAskUser,
+  handleCreatePlan: () => handleCreatePlan,
+  handleListFiles: () => handleListFiles,
+  handleReadFile: () => handleReadFile,
+  handleUpdateEnv: () => handleUpdateEnv,
+  handleUpdateEnvDirect: () => handleUpdateEnvDirect,
+  handleWriteFile: () => handleWriteFile,
+  hasToolCalls: () => hasToolCalls,
+  resolveServiceUrl: () => resolveServiceUrl,
+  shouldCompact: () => shouldCompact
 });
 import * as p16 from "@clack/prompts";
 import pc15 from "picocolors";
+import { readFile as fsReadFile, writeFile as fsWriteFile, mkdir as mkdir8, readdir as readdir2 } from "fs/promises";
+import { join as join15, dirname as dirname7, resolve } from "path";
+function buildServicePayload(messages, metadata) {
+  return { messages, metadata };
+}
+function hasToolCalls(response) {
+  return !!(response.message.toolCalls && response.message.toolCalls.length > 0);
+}
+function formatTokens(count) {
+  if (count >= 1e3) return `${(count / 1e3).toFixed(1)}k`;
+  return `${count}`;
+}
+function formatElapsed(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remaining = seconds % 60;
+  return `${minutes}m ${remaining}s`;
+}
+function formatSessionStats(elapsedMs, totalTokens) {
+  return `Session: ${formatElapsed(elapsedMs)} | ${formatTokens(totalTokens)} tokens`;
+}
+function shouldCompact(lastPromptTokens, threshold) {
+  return lastPromptTokens >= threshold;
+}
+function applyCompaction(messages, summary, keepRecent = 2) {
+  const recent = messages.slice(-keepRecent);
+  return [
+    { role: "user", content: `[Context from earlier in conversation]
+${summary}` },
+    ...recent
+  ];
+}
 async function fetchGlobalRegistries(configuredNamespaces) {
   let directory;
   try {
@@ -3496,9 +3543,6 @@ async function resolveServiceUrl(urlOverride, chatServiceConfig) {
   if (chatServiceConfig?.url) return chatServiceConfig.url;
   return DEFAULT_SERVICE_URL;
 }
-function buildRequestPayload(message, metadata) {
-  return { message, metadata };
-}
 function formatPlan(plan) {
   const lines = [plan.summary, ""];
   for (let i = 0; i < plan.steps.length; i++) {
@@ -3523,6 +3567,246 @@ function formatStepLabel(step) {
       return `Unlink ${pc15.red(step.toolName)} from ${pc15.cyan(step.agentName)}`;
     case "registry-add":
       return `Add registry ${pc15.magenta(step.namespace)}`;
+    case "update":
+      return `Update ${pc15.yellow(step.component)}`;
+  }
+}
+async function executeStep(step) {
+  switch (step.action) {
+    case "registry-add": {
+      const { registryAddCommand: registryAddCommand2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+      await registryAddCommand2(step.namespace, step.url, { overwrite: true });
+      break;
+    }
+    case "add": {
+      const { addCommand: addCommand2 } = await Promise.resolve().then(() => (init_add(), add_exports));
+      await addCommand2([step.component], { yes: true });
+      break;
+    }
+    case "create": {
+      const { createCommand: createCommand2 } = await Promise.resolve().then(() => (init_create(), create_exports));
+      await createCommand2(step.type, step.name);
+      break;
+    }
+    case "link": {
+      const { linkCommand: linkCommand2 } = await Promise.resolve().then(() => (init_link(), link_exports));
+      await linkCommand2("tool", step.toolName, { to: step.agentName });
+      break;
+    }
+    case "remove": {
+      const { removeCommand: removeCommand2 } = await Promise.resolve().then(() => (init_remove(), remove_exports));
+      await removeCommand2(step.component);
+      break;
+    }
+    case "unlink": {
+      const { unlinkCommand: unlinkCommand2 } = await Promise.resolve().then(() => (init_unlink(), unlink_exports));
+      await unlinkCommand2("tool", step.toolName, { from: step.agentName });
+      break;
+    }
+    case "update": {
+      const { addCommand: addCommand2 } = await Promise.resolve().then(() => (init_add(), add_exports));
+      await addCommand2([step.component], { overwrite: true, yes: true });
+      break;
+    }
+  }
+}
+async function handleAskUser(input) {
+  const responses = [];
+  for (const item of input.items) {
+    switch (item.type) {
+      case "info":
+        p16.log.info(item.text);
+        break;
+      case "warning":
+        p16.log.warn(item.text);
+        break;
+      case "confirmation": {
+        const confirmed = await p16.confirm({ message: item.text });
+        if (p16.isCancel(confirmed)) return "User cancelled.";
+        responses.push(confirmed ? "Yes" : "No");
+        break;
+      }
+      case "option": {
+        if (!item.choices?.length) {
+          responses.push("No choices provided.");
+          break;
+        }
+        const selected = await p16.select({
+          message: item.text,
+          options: item.choices.map((c) => ({ value: c, label: c }))
+        });
+        if (p16.isCancel(selected)) return "User cancelled.";
+        responses.push(`User selected: ${selected}`);
+        break;
+      }
+      case "question": {
+        const answer = await p16.text({ message: item.text, placeholder: item.context });
+        if (p16.isCancel(answer)) return "User cancelled.";
+        responses.push(`User answered: ${answer}`);
+        break;
+      }
+    }
+  }
+  return responses.join("\n");
+}
+async function handleCreatePlan(plan, cwd) {
+  p16.log.message(formatPlan(plan));
+  const steps = plan.steps;
+  let selectedSteps;
+  if (steps.length === 1) {
+    const confirm7 = await p16.confirm({ message: `Run: ${formatStepLabel(steps[0])}?` });
+    if (p16.isCancel(confirm7) || !confirm7) return "User cancelled the plan.";
+    selectedSteps = steps;
+  } else {
+    const action = await p16.select({
+      message: "How would you like to proceed?",
+      options: [
+        { value: "all", label: "Yes, run all steps" },
+        { value: "select", label: "Select which steps to run" },
+        { value: "cancel", label: "Cancel" }
+      ]
+    });
+    if (p16.isCancel(action) || action === "cancel") return "User cancelled the plan.";
+    if (action === "select") {
+      const choices = await p16.multiselect({
+        message: "Select steps to run:",
+        options: steps.map((step, i) => ({ value: i, label: `${formatStepLabel(step)} - ${step.reason}` }))
+      });
+      if (p16.isCancel(choices)) return "User cancelled the plan.";
+      selectedSteps = choices.map((i) => steps[i]);
+    } else {
+      selectedSteps = steps;
+    }
+  }
+  const results = [];
+  const s = p16.spinner();
+  for (const step of selectedSteps) {
+    s.start(`Running: ${formatStepLabel(step)}...`);
+    try {
+      await executeStep(step);
+      s.stop(pc15.green(`Done: ${formatStepLabel(step)}`));
+      results.push(`Completed: ${step.action} ${step.component ?? step.name ?? ""}`);
+    } catch (err) {
+      s.stop(pc15.red(`Failed: ${formatStepLabel(step)}`));
+      results.push(`Failed: ${step.action} ${step.component ?? step.name ?? ""} \u2014 ${err.message}`);
+    }
+  }
+  return results.join("\n");
+}
+async function handleWriteFile(input, cwd) {
+  const fullPath = resolve(cwd, input.path);
+  if (!fullPath.startsWith(resolve(cwd))) {
+    return `Rejected: path '${input.path}' would escape project directory`;
+  }
+  await mkdir8(dirname7(fullPath), { recursive: true });
+  await fsWriteFile(fullPath, input.content, "utf-8");
+  p16.log.success(`Wrote ${pc15.cyan(input.path)}${input.description ? ` \u2014 ${input.description}` : ""}`);
+  return `Wrote ${input.path}`;
+}
+async function handleReadFile(input, cwd) {
+  const fullPath = resolve(cwd, input.path);
+  if (!fullPath.startsWith(resolve(cwd))) {
+    return `Rejected: path '${input.path}' would escape project directory`;
+  }
+  try {
+    return await fsReadFile(fullPath, "utf-8");
+  } catch {
+    return `File not found: ${input.path}`;
+  }
+}
+async function handleListFiles(input, cwd) {
+  const searchDir = input.directory ? join15(cwd, input.directory) : cwd;
+  try {
+    const entries = await readdir2(searchDir, { recursive: true });
+    const filtered = entries.filter((e) => {
+      if (input.pattern.startsWith("*.")) {
+        const ext = input.pattern.slice(1);
+        return String(e).endsWith(ext);
+      }
+      return true;
+    });
+    return filtered.length > 0 ? `Files found:
+${filtered.join("\n")}` : "No files found matching the pattern.";
+  } catch {
+    return `Directory not found: ${input.directory ?? "."}`;
+  }
+}
+async function handleUpdateEnv(input, cwd) {
+  const value = await p16.password({ message: `Enter ${input.key} (${input.description}):` });
+  if (p16.isCancel(value) || !value) return "User cancelled.";
+  return handleUpdateEnvDirect(input, cwd, value);
+}
+async function handleUpdateEnvDirect(input, cwd, value) {
+  const envPath = join15(cwd, ".env");
+  let existing = "";
+  try {
+    existing = await fsReadFile(envPath, "utf-8");
+  } catch {
+  }
+  const lines = existing.split("\n");
+  const keyIndex = lines.findIndex((l) => l.startsWith(`${input.key}=`));
+  let newContent;
+  if (keyIndex >= 0) {
+    lines[keyIndex] = `${input.key}=${value}`;
+    newContent = lines.join("\n");
+  } else {
+    newContent = existing + (existing && !existing.endsWith("\n") ? "\n" : "") + `${input.key}=${value}
+`;
+  }
+  await fsWriteFile(envPath, newContent, "utf-8");
+  p16.log.success(`Set ${pc15.cyan(input.key)} in .env`);
+  return `Successfully set ${input.key} in .env`;
+}
+async function handleToolCalls(toolCalls, cwd) {
+  const results = [];
+  for (const call of toolCalls) {
+    let result;
+    try {
+      switch (call.name) {
+        case "askUser":
+          result = await handleAskUser(call.input);
+          break;
+        case "createPlan":
+          result = await handleCreatePlan(call.input, cwd);
+          break;
+        case "writeFile":
+          result = await handleWriteFile(call.input, cwd);
+          break;
+        case "readFile":
+          result = await handleReadFile(call.input, cwd);
+          break;
+        case "listFiles":
+          result = await handleListFiles(call.input, cwd);
+          break;
+        case "updateEnv":
+          result = await handleUpdateEnv(call.input, cwd);
+          break;
+        default:
+          result = `Unknown tool: ${call.name}`;
+      }
+    } catch (err) {
+      result = `Error executing ${call.name}: ${err.message ?? "Unknown error"}`;
+    }
+    results.push({ toolCallId: call.id, result });
+  }
+  return results;
+}
+async function compactConversation(messages, serviceUrl) {
+  try {
+    const headers = { "Content-Type": "application/json" };
+    if (process.env.KITN_API_KEY) headers["Authorization"] = `Bearer ${process.env.KITN_API_KEY}`;
+    const res = await fetch(`${serviceUrl}/api/chat/compact`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ messages })
+    });
+    if (res.ok) {
+      const data = await res.json();
+      const compacted = applyCompaction(messages, data.summary);
+      messages.length = 0;
+      messages.push(...compacted);
+    }
+  } catch {
   }
 }
 async function chatCommand(message, opts) {
@@ -3532,11 +3816,18 @@ async function chatCommand(message, opts) {
     p16.log.error("No kitn.json found. Run `kitn init` first.");
     process.exit(1);
   }
+  p16.intro(pc15.bold("kitn assistant"));
   if (!message) {
-    p16.log.error('Please provide a message. Usage: kitn chat "add a weather tool"');
-    process.exit(1);
+    const input = await p16.text({
+      message: "What would you like to do?",
+      placeholder: "e.g., I want to build a weather agent"
+    });
+    if (p16.isCancel(input) || !input) {
+      p16.cancel("Cancelled.");
+      return;
+    }
+    message = input;
   }
-  p16.intro(pc15.bold("kitn assistant"));
   const s = p16.spinner();
   s.start("Gathering project context...");
   let registryIndex;
@@ -3568,141 +3859,70 @@ async function chatCommand(message, opts) {
     globalRegistryIndex = globalEntries.length > 0 ? globalEntries : void 0;
   } catch {
     s.stop(pc15.red("Failed to gather context"));
-    p16.log.error("Could not read project context. Check your kitn.json and network connection.");
+    p16.log.error("Could not read project context.");
     process.exit(1);
   }
   s.stop("Context gathered");
-  s.start("Thinking...");
+  const messages = [{ role: "user", content: message }];
   const serviceUrl = await resolveServiceUrl(opts?.url, config2.chatService);
   const metadata = { registryIndex, installed };
   if (globalRegistryIndex) metadata.globalRegistryIndex = globalRegistryIndex;
-  const payload = buildRequestPayload(message, metadata);
-  let response;
-  try {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (process.env.KITN_API_KEY) {
-      headers["Authorization"] = `Bearer ${process.env.KITN_API_KEY}`;
-    }
-    response = await fetch(`${serviceUrl}/api/chat`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(payload)
-    });
-  } catch (err) {
-    s.stop(pc15.red("Connection failed"));
-    p16.log.error(`Could not reach chat service at ${serviceUrl}. ${err.message ?? ""}`);
-    process.exit(1);
-  }
-  if (!response.ok) {
-    s.stop(pc15.red("Request failed"));
-    p16.log.error(`Chat service returned ${response.status}: ${response.statusText}`);
-    process.exit(1);
-  }
-  let data;
-  try {
-    data = await response.json();
-  } catch {
-    s.stop(pc15.red("Invalid response"));
-    p16.log.error("Chat service returned an invalid response.");
-    process.exit(1);
-  }
-  s.stop("Done");
-  if (data.rejected) {
-    p16.log.warn(data.text ?? "Request was rejected by the assistant.");
-    p16.outro("Try rephrasing your request.");
-    return;
-  }
-  if (!data.plan) {
-    p16.log.info(data.text ?? "No actionable plan returned.");
-    p16.outro("Nothing to do.");
-    return;
-  }
-  p16.log.message(formatPlan(data.plan));
-  const steps = data.plan.steps;
-  let selectedSteps;
-  if (steps.length === 1) {
-    const confirm7 = await p16.confirm({
-      message: `Run: ${formatStepLabel(steps[0])}?`
-    });
-    if (p16.isCancel(confirm7) || !confirm7) {
-      p16.cancel("Cancelled.");
-      return;
-    }
-    selectedSteps = steps;
-  } else {
-    const action = await p16.select({
-      message: "How would you like to proceed?",
-      options: [
-        { value: "all", label: "Yes, run all steps" },
-        { value: "select", label: "Select which steps to run" },
-        { value: "cancel", label: "Cancel" }
-      ]
-    });
-    if (p16.isCancel(action) || action === "cancel") {
-      p16.cancel("Cancelled.");
-      return;
-    }
-    if (action === "select") {
-      const choices = await p16.multiselect({
-        message: "Select steps to run:",
-        options: steps.map((step, i) => ({
-          value: i,
-          label: `${formatStepLabel(step)} - ${step.reason}`
-        }))
-      });
-      if (p16.isCancel(choices)) {
-        p16.cancel("Cancelled.");
-        return;
-      }
-      selectedSteps = choices.map((i) => steps[i]);
-    } else {
-      selectedSteps = steps;
-    }
-  }
-  for (const step of selectedSteps) {
-    s.start(`Running: ${formatStepLabel(step)}...`);
+  let totalTokens = 0;
+  let lastInputTokens = 0;
+  const sessionStart = Date.now();
+  const MAX_PROMPT_TOKENS = 1e5;
+  while (true) {
+    const turnStart = Date.now();
+    if (shouldCompact(lastInputTokens, MAX_PROMPT_TOKENS)) {
+      s.start("Compacting conversation...");
+      await compactConversation(messages, serviceUrl);
+      s.stop(pc15.dim("Conversation compacted."));
+    }
+    s.start("Thinking...");
+    let response;
     try {
-      switch (step.action) {
-        case "registry-add": {
-          const { registryAddCommand: registryAddCommand2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-          await registryAddCommand2(step.namespace, step.url, { overwrite: true });
-          break;
-        }
-        case "add": {
-          const { addCommand: addCommand2 } = await Promise.resolve().then(() => (init_add(), add_exports));
-          await addCommand2([step.component], { yes: true });
-          break;
-        }
-        case "create": {
-          const { createCommand: createCommand2 } = await Promise.resolve().then(() => (init_create(), create_exports));
-          await createCommand2(step.type, step.name);
-          break;
-        }
-        case "link": {
-          const { linkCommand: linkCommand2 } = await Promise.resolve().then(() => (init_link(), link_exports));
-          await linkCommand2("tool", step.toolName, { to: step.agentName });
-          break;
-        }
-        case "remove": {
-          const { removeCommand: removeCommand2 } = await Promise.resolve().then(() => (init_remove(), remove_exports));
-          await removeCommand2(step.component);
-          break;
-        }
-        case "unlink": {
-          const { unlinkCommand: unlinkCommand2 } = await Promise.resolve().then(() => (init_unlink(), unlink_exports));
-          await unlinkCommand2("tool", step.toolName, { from: step.agentName });
-          break;
-        }
+      const headers = { "Content-Type": "application/json" };
+      if (process.env.KITN_API_KEY) headers["Authorization"] = `Bearer ${process.env.KITN_API_KEY}`;
+      const res = await fetch(`${serviceUrl}/api/chat`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(buildServicePayload(messages, metadata))
+      });
+      if (!res.ok) {
+        s.stop(pc15.red("Request failed"));
+        p16.log.error(`Chat service returned ${res.status}: ${res.statusText}`);
+        break;
       }
-      s.stop(pc15.green(`Done: ${formatStepLabel(step)}`));
+      response = await res.json();
     } catch (err) {
-      s.stop(pc15.red(`Failed: ${formatStepLabel(step)}`));
-      p16.log.error(err.message ?? "Unknown error");
+      s.stop(pc15.red("Connection failed"));
+      p16.log.error(`Could not reach chat service at ${serviceUrl}. ${err.message ?? ""}`);
+      break;
     }
+    const elapsed = Date.now() - turnStart;
+    totalTokens += response.usage.outputTokens;
+    lastInputTokens = response.usage.inputTokens;
+    if (response.rejected) {
+      s.stop("Done");
+      p16.log.warn(response.text ?? "Request was rejected.");
+      break;
+    }
+    if (!hasToolCalls(response)) {
+      s.stop(`Done ${pc15.dim(`(${formatElapsed(elapsed)} | ${formatTokens(response.usage.outputTokens)} tokens)`)}`);
+      if (response.message.content) p16.log.message(response.message.content);
+      break;
+    }
+    s.stop(`${pc15.dim(`(${formatElapsed(elapsed)} | ${formatTokens(response.usage.outputTokens)} tokens)`)}`);
+    messages.push({
+      role: "assistant",
+      content: response.message.content,
+      toolCalls: response.message.toolCalls
+    });
+    const toolResults = await handleToolCalls(response.message.toolCalls, cwd);
+    messages.push({ role: "tool", toolResults });
   }
-  p16.outro(pc15.green("All done! Run your dev server to test the new components."));
+  const totalElapsed = Date.now() - sessionStart;
+  p16.outro(pc15.green("Done! ") + pc15.dim(formatSessionStats(totalElapsed, totalTokens)));
 }
 var DEFAULT_SERVICE_URL, GLOBAL_REGISTRY_URL;
 var init_chat = __esm({
@@ -3719,7 +3939,7 @@ var init_chat = __esm({
 // src/index.ts
 init_update_check();
 import { Command } from "commander";
-var VERSION = true ? "0.1.35" : "0.0.0-dev";
+var VERSION = true ? "0.1.36" : "0.0.0-dev";
 var printUpdateNotice = startUpdateCheck(VERSION);
 var program = new Command().name("kitn").description("Install AI agent components from the kitn registry").version(VERSION);
 program.command("init").description("Initialize kitn in your project").option("-r, --runtime <runtime>", "runtime to use (bun, node, deno)").option("-f, --framework <framework>", "HTTP framework (hono, hono-openapi, elysia)").option("-b, --base <path>", "base directory for components (default: src/ai)").option("-y, --yes", "accept all defaults without prompting").action(async (opts) => {
@@ -3770,7 +3990,7 @@ program.command("rules").description("Regenerate AI coding tool rules files").ac
   const { rulesCommand: rulesCommand2 } = await Promise.resolve().then(() => (init_rules(), rules_exports));
   await rulesCommand2();
 });
-program.command("chat").description("AI-powered scaffolding assistant \u2014 describe what you need in plain English").argument("<message>", 'what you want to build (e.g. "I want a weather agent")').option("-u, --url <url>", "chat service URL (overrides config and default)").action(async (message, opts) => {
+program.command("chat").description("AI-powered scaffolding assistant").argument("[message]", "What you want to do").option("-u, --url <url>", "Chat service URL").action(async (message, opts) => {
   const { chatCommand: chatCommand2 } = await Promise.resolve().then(() => (init_chat(), chat_exports));
   await chatCommand2(message, opts);
 });