@thejeetsingh/kalcode 2.0.0 → 2.2.0

package/src/agent/loop.ts

@@ -1,282 +0,0 @@
-import { streamChat } from "../api/client.js";
-import { getAllDefinitions, executeToolCall } from "../tools/registry.js";
-import { addMessage, getMessages } from "./history.js";
-import { MAX_LOOP_ITERATIONS } from "../constants.js";
-import type { Message, ToolCallAccumulator, TokenUsage } from "../types.js";
-import {
-  startSpinner,
-  stopSpinner,
-  updateSpinner,
-  succeedSpinner,
-  failSpinner,
-} from "../ui/spinner.js";
-import {
-  renderToolCall,
-  renderToolResult,
-  renderError,
-  renderUsage,
-  renderRetryWait,
-} from "../ui/terminal.js";
-import { writeStreamToken, finishStream } from "../ui/stream-renderer.js";
-import { parseTextToolCalls } from "./text-tool-parser.js";
-import { needsPermission, requestPermission } from "./permissions.js";
-
-let compactMode = false;
-let interrupted = false;
-let askMode = false;
-
-export function setCompact(val: boolean): void { compactMode = val; }
-export function getCompact(): boolean { return compactMode; }
-export function setAskMode(val: boolean): void { askMode = val; }
-export function getAskMode(): boolean { return askMode; }
-export function interruptAgent(): void { interrupted = true; }
-
-export async function runAgentLoop(
-  apiKey: string,
-  model: string,
-  userMessage: string
-): Promise<void> {
-  addMessage({ role: "user", content: userMessage });
-  interrupted = false;
-
-  // In ask mode, only use read-only tools
-  const allDefs = getAllDefinitions();
-  const toolDefs = askMode
-    ? allDefs.filter(t => !["writeFile", "editFile", "runCommand"].includes(t.function.name))
-    : allDefs;
-
-  let totalUsage: TokenUsage = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-
-  for (let iteration = 0; iteration < MAX_LOOP_ITERATIONS; iteration++) {
-    if (interrupted) break;
-
-    startSpinner("thinking");
-
-    let textContent = "";
-    const toolCallAccumulators: Map<number, ToolCallAccumulator> = new Map();
-    let hasError = false;
-    let turnUsage: TokenUsage | null = null;
-
-    try {
-      let firstToken = true;
-      const stream = streamChat(
-        apiKey,
-        model,
-        getMessages(),
-        toolDefs,
-        (attempt, waitSec) => {
-          renderRetryWait(attempt, waitSec);
-        }
-      );
-
-      for await (const delta of stream) {
-        if (interrupted) break;
-
-        if (delta.type === "content" && delta.content) {
-          if (firstToken) {
-            stopSpinner();
-            firstToken = false;
-          }
-          textContent += delta.content;
-          // Only stream text if we haven't seen tool calls yet
-          if (toolCallAccumulators.size === 0) {
-            writeStreamToken(delta.content);
-          }
-        } else if (delta.type === "tool_call" && delta.toolCall) {
-          // If we were streaming text and now got tool calls, clear the text
-          if (toolCallAccumulators.size === 0 && textContent.trim()) {
-            if (!firstToken) {
-              clearStreamedText(textContent);
-              finishStream();
-            }
-          }
-          if (firstToken) {
-            firstToken = false;
-          }
-          const tc = delta.toolCall;
-          if (!toolCallAccumulators.has(tc.index)) {
-            toolCallAccumulators.set(tc.index, {
-              id: tc.id || "",
-              function: { name: "", arguments: "" },
-            });
-          }
-          const acc = toolCallAccumulators.get(tc.index)!;
-          if (tc.id) acc.id = tc.id;
-          if (tc.function?.name) acc.function.name += tc.function.name;
-          if (tc.function?.arguments) acc.function.arguments += tc.function.arguments;
-          // Show what tool is being prepared
-          const toolName = acc.function.name || "tool call";
-          updateSpinner(`preparing ${toolName}`);
-        } else if (delta.type === "error") {
-          stopSpinner();
-          renderError(delta.error || "Unknown API error");
-          hasError = true;
-          break;
-        }
-
-        if (delta.usage) turnUsage = delta.usage;
-      }
-    } catch (err: unknown) {
-      stopSpinner();
-      renderError(`Stream error: ${err instanceof Error ? err.message : String(err)}`);
-      return;
-    }
-
-    if (interrupted) {
-      stopSpinner();
-      finishStream();
-      break;
-    }
-
-    // Parse text-based tool calls
-    if (toolCallAccumulators.size === 0 && textContent.trim()) {
-      const parsed = parseTextToolCalls(textContent);
-      if (parsed && parsed.length > 0) {
-        clearStreamedText(textContent);
-        for (const tc of parsed) {
-          toolCallAccumulators.set(toolCallAccumulators.size, tc);
-        }
-        textContent = "";
-      }
-    }
-
-    // Stop spinner after stream ends (was still running during tool_call accumulation)
-    stopSpinner();
-
-    if (toolCallAccumulators.size > 0 && textContent.trim()) {
-      clearStreamedText(textContent);
-    }
-
-    finishStream();
-
-    if (hasError) return;
-
-    if (turnUsage) {
-      totalUsage.prompt_tokens += turnUsage.prompt_tokens;
-      totalUsage.completion_tokens += turnUsage.completion_tokens;
-      totalUsage.total_tokens += turnUsage.total_tokens;
-    }
-
-    const assistantMsg: Message = {
-      role: "assistant",
-      content: toolCallAccumulators.size > 0 ? null : (textContent || null),
-    };
-
-    if (toolCallAccumulators.size > 0) {
-      assistantMsg.tool_calls = Array.from(toolCallAccumulators.values()).map(
-        (acc) => ({
-          id: acc.id,
-          type: "function" as const,
-          function: {
-            name: acc.function.name,
-            arguments: acc.function.arguments,
-          },
-        })
-      );
-    }
-
-    addMessage(assistantMsg);
-
-    if (!assistantMsg.tool_calls || assistantMsg.tool_calls.length === 0) {
-      renderUsage(totalUsage.total_tokens > 0 ? totalUsage : null);
-      return;
-    }
-
-    // Execute tool calls
-    for (const tc of assistantMsg.tool_calls) {
-      if (interrupted) break;
-
-      let parsedArgs: Record<string, unknown>;
-      try {
-        parsedArgs = JSON.parse(tc.function.arguments || "{}");
-      } catch {
-        parsedArgs = {};
-      }
-
-      const toolName = tc.function.name;
-      const summary = formatPermissionSummary(toolName, parsedArgs);
-
-      // Permission check for write operations
-      if (needsPermission(toolName)) {
-        const allowed = await requestPermission(toolName, summary);
-        if (!allowed) {
-          renderToolCall(toolName, parsedArgs);
-          console.log(`  ${chalk.dim("⎿")}  ${chalk.yellow("Denied by user")}`);
-          addMessage({
-            role: "tool",
-            tool_call_id: tc.id,
-            content: "Permission denied by user. Do not retry this operation.",
-          });
-          continue;
-        }
-      }
-
-      renderToolCall(toolName, parsedArgs);
-      startSpinner(toolName);
-
-      try {
-        const result = await executeToolCall(toolName, parsedArgs);
-        succeedSpinner(toolName);
-        renderToolResult(toolName, result, compactMode);
-
-        addMessage({
-          role: "tool",
-          tool_call_id: tc.id,
-          content: result,
-        });
-      } catch (err: unknown) {
-        failSpinner(`${toolName} failed`);
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        renderError(errorMsg);
-
-        addMessage({
-          role: "tool",
-          tool_call_id: tc.id,
-          content: `Error: ${errorMsg}`,
-        });
-      }
-    }
-  }
-
-  if (interrupted) {
-    console.log("");
-  } else if (!interrupted) {
-    renderError("Agent loop reached maximum iterations");
-  }
-}
-
-function clearStreamedText(text: string): void {
-  const cols = Math.max(20, process.stdout.columns || 80);
-  const lines = text.split("\n");
-  let rowsToClear = 0;
-
-  for (const line of lines) {
-    // Account for soft-wrapped rows to avoid leaving visual artifacts.
-    const len = Math.max(1, line.length);
-    rowsToClear += Math.ceil(len / cols);
-  }
-
-  for (let i = 0; i < rowsToClear; i++) {
-    process.stdout.write("\x1b[2K");
-    if (i < rowsToClear - 1) {
-      process.stdout.write("\x1b[A");
-    }
-  }
-  process.stdout.write("\r");
-}
-
-function formatPermissionSummary(name: string, args: Record<string, unknown>): string {
-  switch (name) {
-    case "writeFile":
-      return String(args.filePath || "");
-    case "editFile":
-      return String(args.filePath || "");
-    case "runCommand":
-      return `$ ${String(args.command || "").slice(0, 60)}`;
-    default:
-      return "";
-  }
-}
-
-// Need chalk for the denied message
-import chalk from "chalk";

package/src/agent/memory.ts

@@ -1,26 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-
-const MEMORY_FILES = ["KALCODE.md", "CONVENTIONS.md", ".kalcode.md"];
-
-export function loadProjectMemory(cwd: string): string | null {
-  for (const name of MEMORY_FILES) {
-    const path = join(cwd, name);
-    if (existsSync(path)) {
-      try {
-        const content = readFileSync(path, "utf-8").trim();
-        if (content) return content;
-      } catch {
-        // ignore
-      }
-    }
-  }
-  return null;
-}
-
-export function getMemoryFileName(cwd: string): string | null {
-  for (const name of MEMORY_FILES) {
-    if (existsSync(join(cwd, name))) return name;
-  }
-  return null;
-}

package/src/agent/permissions.ts

@@ -1,84 +0,0 @@
-import chalk from "chalk";
-
-export type PermissionLevel = "ask" | "auto" | "deny-writes";
-
-let permissionLevel: PermissionLevel = "ask";
-const sessionApprovals = new Set<string>();
-
-export function setPermissionLevel(level: PermissionLevel): void {
-  permissionLevel = level;
-}
-
-export function getPermissionLevel(): PermissionLevel {
-  return permissionLevel;
-}
-
-// Tools that modify state
-const WRITE_TOOLS = new Set(["writeFile", "editFile", "runCommand"]);
-
-export function needsPermission(toolName: string): boolean {
-  if (permissionLevel === "auto") return false;
-  if (permissionLevel === "deny-writes" && WRITE_TOOLS.has(toolName))
-    return false;
-  return WRITE_TOOLS.has(toolName);
-}
-
-export async function requestPermission(
-  toolName: string,
-  summary: string,
-): Promise<boolean> {
-  const key = `${toolName}:${summary}`;
-  if (sessionApprovals.has(key)) return true;
-
-  // Claude Code style: ? marker with clean options
-  const promptText =
-    `  ${chalk.yellow("?")} Allow ${chalk.bold.white(toolName)}` +
-    (summary ? ` ${chalk.dim(summary)}` : "") +
-    `  ${chalk.dim("(y)es / (n)o / (a)lways")} `;
-
-  process.stdout.write(promptText);
-
-  const answer = await readSingleKey();
-  const writeDecision = (decision: string, color: (text: string) => string): void => {
-    // Redraw the line to eliminate any echoed keypress artifacts (e.g. "yyes").
-    process.stdout.write(`\r\x1b[2K${promptText}${color(decision)}\n`);
-  };
-
-  if (answer === "a") {
-    writeDecision("always", chalk.green);
-    setPermissionLevel("auto");
-    return true;
-  }
-
-  if (answer === "y" || answer === "\r" || answer === "\n") {
-    writeDecision("yes", chalk.green);
-    sessionApprovals.add(key);
-    return true;
-  }
-
-  writeDecision("no", chalk.red);
-  return false;
-}
-
-function readSingleKey(): Promise<string> {
-  return new Promise((resolve) => {
-    const stdin = process.stdin;
-    const wasRaw = stdin.isRaw;
-    stdin.setRawMode(true);
-    stdin.resume();
-
-    function onData(data: Buffer) {
-      stdin.removeListener("data", onData);
-      stdin.setRawMode(wasRaw ?? false);
-      const key = data.toString();
-      // Ctrl+C
-      if (key === "\x03") {
-        resolve("n");
-        return;
-      }
-      resolve(key.toLowerCase());
-    }
-
-    stdin.on("data", onData);
-  });
-}

package/src/agent/text-tool-parser.ts

@@ -1,71 +0,0 @@
-import type { ToolCallAccumulator } from "../types.js";
-
-// Parse tool calls from model text output when the model doesn't use
-// the proper tool_call API. Handles formats like:
-// ```tool_code
-// [toolName(arg1='val1', arg2='val2')]
-// ```
-// or JSON-like: {"name": "toolName", "arguments": {"arg": "val"}}
-
-export function parseTextToolCalls(text: string): ToolCallAccumulator[] | null {
-  const results: ToolCallAccumulator[] = [];
-
-  // Pattern 1: ```tool_code blocks (gemma style)
-  const toolCodeRegex = /```tool_code\s*\n([\s\S]*?)```/g;
-  let match;
-  while ((match = toolCodeRegex.exec(text)) !== null) {
-    const block = match[1]!.trim();
-    const calls = parseToolCodeBlock(block);
-    results.push(...calls);
-  }
-
-  if (results.length > 0) return results;
-
-  // Pattern 2: [toolName(args)] without code blocks
-  const bracketRegex = /\[(\w+)\(([^)]*)\)\]/g;
-  while ((match = bracketRegex.exec(text)) !== null) {
-    const name = match[1]!;
-    const argsStr = match[2]!;
-    const args = parseKeyValueArgs(argsStr);
-    results.push({
-      id: `text-${Date.now()}-${results.length}`,
-      function: { name, arguments: JSON.stringify(args) },
-    });
-  }
-
-  return results.length > 0 ? results : null;
-}
-
-function parseToolCodeBlock(block: string): ToolCallAccumulator[] {
-  const results: ToolCallAccumulator[] = [];
-  // Match [toolName(key='value', key2='value2')] or [toolName(key="value")]
-  const callRegex = /\[?(\w+)\(([^)]*)\)\]?/g;
-  let match;
-  while ((match = callRegex.exec(block)) !== null) {
-    const name = match[1]!;
-    const argsStr = match[2]!;
-    const args = parseKeyValueArgs(argsStr);
-    results.push({
-      id: `text-${Date.now()}-${results.length}`,
-      function: { name, arguments: JSON.stringify(args) },
-    });
-  }
-  return results;
-}
-
-function parseKeyValueArgs(argsStr: string): Record<string, unknown> {
-  const args: Record<string, unknown> = {};
-  // Match key='value' or key="value" or key=value or key=true/false/number
-  const argRegex = /(\w+)\s*=\s*(?:'([^']*)'|"([^"]*)"|(\S+))/g;
-  let match;
-  while ((match = argRegex.exec(argsStr)) !== null) {
-    const key = match[1]!;
-    const value = match[2] ?? match[3] ?? match[4]!;
-    // Try to parse as boolean/number
-    if (value === "true") args[key] = true;
-    else if (value === "false") args[key] = false;
-    else if (!isNaN(Number(value)) && value !== "") args[key] = Number(value);
-    else args[key] = value;
-  }
-  return args;
-}

package/src/api/client.ts

@@ -1,110 +0,0 @@
-import { API_URL, RATE_LIMIT_MAX, RATE_LIMIT_WINDOW, MAX_RETRIES, RETRY_BASE_DELAY } from "../constants.js";
-import type { Message, StreamDelta, ToolDefinition } from "../types.js";
-import { parseSSEStream } from "./stream-parser.js";
-
-const requestTimestamps: number[] = [];
-
-async function waitForRateLimit(): Promise<void> {
-  const now = Date.now();
-  while (requestTimestamps.length > 0 && requestTimestamps[0]! < now - RATE_LIMIT_WINDOW) {
-    requestTimestamps.shift();
-  }
-
-  if (requestTimestamps.length >= RATE_LIMIT_MAX) {
-    const oldestInWindow = requestTimestamps[0]!;
-    const waitMs = oldestInWindow + RATE_LIMIT_WINDOW - now + 100;
-    if (waitMs > 0) {
-      await new Promise((resolve) => setTimeout(resolve, waitMs));
-    }
-  }
-
-  requestTimestamps.push(Date.now());
-}
-
-export async function* streamChat(
-  apiKey: string,
-  model: string,
-  messages: Message[],
-  tools?: ToolDefinition[],
-  onRetry?: (attempt: number, waitSec: number) => void
-): AsyncGenerator<StreamDelta> {
-  const proxyUrl = (process.env.KALCODE_PROXY_URL || "").trim();
-  const proxyToken = (process.env.KALCODE_PROXY_TOKEN || "").trim();
-  const targetUrl = proxyUrl
-    ? `${proxyUrl.replace(/\/+$/, "")}/v1/chat/completions`
-    : API_URL;
-  const authToken = proxyUrl ? proxyToken : apiKey;
-
-  if (proxyUrl && !proxyToken) {
-    yield {
-      type: "error",
-      error: "KALCODE_PROXY_URL is set but KALCODE_PROXY_TOKEN is missing.",
-    };
-    return;
-  }
-
-  if (!authToken) {
-    yield {
-      type: "error",
-      error: proxyUrl
-        ? "Missing proxy auth token."
-        : "Missing NVIDIA API key.",
-    };
-    return;
-  }
-
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    await waitForRateLimit();
-
-    const body: Record<string, unknown> = {
-      model,
-      messages,
-      stream: true,
-      max_tokens: 16384,
-      temperature: 0,
-    };
-
-    if (tools && tools.length > 0) {
-      body.tools = tools;
-      body.tool_choice = "auto";
-    }
-
-    const response = await fetch(targetUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${authToken}`,
-      },
-      body: JSON.stringify(body),
-    });
-
-    if (response.status === 429 && attempt < MAX_RETRIES) {
-      const retryAfter = response.headers.get("retry-after");
-      const waitMs = retryAfter
-        ? parseInt(retryAfter) * 1000
-        : RETRY_BASE_DELAY * (attempt + 1);
-      const waitSec = Math.ceil(waitMs / 1000);
-      onRetry?.(attempt + 1, waitSec);
-      await new Promise((resolve) => setTimeout(resolve, waitMs));
-      continue;
-    }
-
-    if (!response.ok) {
-      const text = await response.text();
-      let errorMsg: string;
-      try {
-        const parsed = JSON.parse(text);
-        errorMsg = parsed.error?.message || text;
-      } catch {
-        errorMsg = text;
-      }
-      yield { type: "error", error: `API error ${response.status}: ${errorMsg}` };
-      return;
-    }
-
-    yield* parseSSEStream(response);
-    return;
-  }
-
-  yield { type: "error", error: "Max retries exceeded (rate limited)" };
-}

package/src/api/stream-parser.ts

@@ -1,109 +0,0 @@
-import type { StreamDelta } from "../types.js";
-
-export async function* parseSSEStream(
-  response: Response
-): AsyncGenerator<StreamDelta> {
-  const reader = response.body?.getReader();
-  if (!reader) {
-    yield { type: "error", error: "No response body" };
-    return;
-  }
-
-  const decoder = new TextDecoder();
-  let buffer = "";
-
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith(":")) continue;
-
-        if (trimmed.startsWith("data: ")) {
-          const data = trimmed.slice(6);
-          if (data === "[DONE]") {
-            yield { type: "done" };
-            return;
-          }
-
-          try {
-            const parsed = JSON.parse(data);
-
-            if (parsed.error) {
-              yield {
-                type: "error",
-                error:
-                  typeof parsed.error === "string"
-                    ? parsed.error
-                    : parsed.error.message || JSON.stringify(parsed.error),
-              };
-              continue;
-            }
-
-            const choice = parsed.choices?.[0];
-            if (!choice) {
-              // Check for usage in non-choice chunks
-              if (parsed.usage) {
-                yield {
-                  type: "done",
-                  usage: {
-                    prompt_tokens: parsed.usage.prompt_tokens || 0,
-                    completion_tokens: parsed.usage.completion_tokens || 0,
-                    total_tokens: parsed.usage.total_tokens || 0,
-                  },
-                };
-              }
-              continue;
-            }
-
-            const delta = choice.delta;
-            if (!delta) continue;
-
-            // Build the base delta
-            if (delta.content) {
-              yield { type: "content", content: delta.content };
-            }
-
-            if (delta.tool_calls) {
-              for (const tc of delta.tool_calls) {
-                yield {
-                  type: "tool_call",
-                  toolCall: {
-                    index: tc.index,
-                    id: tc.id,
-                    function: tc.function,
-                  },
-                };
-              }
-            }
-
-            // Extract usage if present
-            if (parsed.usage) {
-              yield {
-                type: "content",
-                content: "",
-                usage: {
-                  prompt_tokens: parsed.usage.prompt_tokens || 0,
-                  completion_tokens: parsed.usage.completion_tokens || 0,
-                  total_tokens: parsed.usage.total_tokens || 0,
-                },
-              };
-            }
-          } catch {
-            // skip malformed JSON chunks
-          }
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-
-  yield { type: "done" };
-}