kronk-cli 0.1.0

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "kronk-cli",
+  "version": "0.1.0",
+  "description": "A Claude-Code-style terminal agent for local models served by Kronk.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "bin": {
+    "kronk-cli": "./src/index.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE",
+    "NOTICE"
+  ],
+  "keywords": [
+    "kronk",
+    "llm",
+    "local",
+    "agent",
+    "cli",
+    "qwen",
+    "llama.cpp",
+    "offline"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "test": "node --test test/*.test.js",
+    "lint": "eslint .",
+    "check": "npm run lint && npm test"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.8.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BardiaN/kronk-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/BardiaN/kronk-cli/issues"
+  },
+  "homepage": "https://github.com/BardiaN/kronk-cli#readme",
+  "author": "Bardia Navvabian"
+}

package/src/agent.js

@@ -0,0 +1,190 @@
+import { streamChat } from './client.js';
+import { TOOLS, NEEDS_APPROVAL, runTool, describe, preview, mcpNeedsApproval } from './tools.js';
+import { config } from './config.js';
+import { c, fmtUsage, spinner, liveLine } from './ui.js';
+import { compact, isOverflow, report } from './compact.js';
+import { maybeDistill } from './distill.js';
+
+export const SYSTEM = `You are kronk-cli, a terse coding assistant running fully offline on the user's machine.
+
+Rules:
+- Inspect before you answer. Use read_file / list_dir / search rather than guessing at code.
+- Prefer one decisive action over narrating options.
+- Keep prose short. Code blocks should be complete and runnable.
+- The working directory is the user's project root. Paths are relative to it.`;
+
+export const SYSTEM_AUTO = `${SYSTEM}
+
+You are running autonomously on a whole task. Finish it before you stop.
+- Do not ask the user questions. Make a reasonable choice and proceed.
+- After you write code, RUN it with bash and fix whatever breaks.
+- Never claim something works unless you have executed it and seen the output.
+- Work in small steps: one file or one command per tool call.
+- When the task is genuinely done, reply with a short summary of what you changed.`;
+
+/**
+ * Run one user turn to completion, looping while the model requests tools.
+ * `approve(name, args)` returns a boolean; used for mutating tools.
+ */
+/** Compact in place, preserving the caller's array identity. */
+async function compactInto(messages, model, signal) {
+  const res = await compact(messages, { model, signal });
+  if (res.failed || res.skipped) { console.log(report(res)); return false; }
+  messages.splice(0, messages.length, ...res.messages);
+  console.log(report(res));
+  return true;
+}
+
+export async function runTurn({ messages, model, signal, approve, mcp, maxSteps = config.maxSteps }) {
+  const tools = mcp ? [...TOOLS, ...mcp.toolDefs()] : TOOLS;
+  let totalUsage = null;
+  let step = 0;
+  let compacted = false;
+
+  for (;;) {
+    step += 1;
+    if (Number.isFinite(maxSteps) && step > maxSteps) {
+      console.log(c.yellow(`  ⛔ step cap reached (${maxSteps}). Stopping.`));
+      console.log(c.grey('     raise it with --steps N, or /steps N in the REPL'));
+      messages.push({ role: 'assistant', content: '(stopped: step cap reached)' });
+      return messages;
+    }
+    let sp = spinner('thinking');
+    let text = '';
+    let calls = [];
+    let wroteAnything = false;
+    let inReasoning = false;
+
+    try {
+      for await (const ev of streamChat({
+        model, messages, tools, signal, maxTokens: config.maxTokens, noThink: config.noThink,
+      })) {
+        if (ev.type === 'reasoning') {
+          if (!config.showThinking) continue;
+          if (sp) { sp.stop(); sp = null; }
+          if (!inReasoning) { process.stdout.write(c.grey('\n  ┄ thinking ┄\n  ')); inReasoning = true; }
+          process.stdout.write(c.grey(ev.value.replace(/\n/g, '\n  ')));
+          wroteAnything = true;
+        }
+
+        else if (ev.type === 'text') {
+          if (sp) { sp.stop(); sp = null; }
+          if (inReasoning) { process.stdout.write(c.grey('\n  ┄─────────┄\n\n')); inReasoning = false; }
+          text += ev.value;
+          process.stdout.write(ev.value);
+          wroteAnything = true;
+        }
+
+        else if (ev.type === 'usage') {
+          totalUsage = ev.value;
+        }
+
+        else if (ev.type === 'done') {
+          calls = ev.calls;
+        }
+      }
+    } catch (e) {
+      if (sp) { sp.stop(); sp = null; }
+      if (isOverflow(e) && !compacted) {
+        compacted = true;
+        console.log(c.yellow('\n  context full — compacting and retrying'));
+        if (await compactInto(messages, model, signal)) { step -= 1; continue; }
+      }
+      throw e;
+    } finally {
+      if (sp) sp.stop();
+    }
+
+    if (inReasoning) process.stdout.write(c.grey('\n  ┄─────────┄\n'));
+    if (wroteAnything) process.stdout.write('\n');
+    if (totalUsage) {
+      console.log(fmtUsage(totalUsage, config.contextWindow));
+      config.lastUsed = (totalUsage.prompt_tokens ?? 0) + (totalUsage.completion_tokens ?? 0);
+    }
+
+    if (config.autoCompact && config.contextWindow && totalUsage) {
+      const used = (totalUsage.prompt_tokens ?? 0) + (totalUsage.completion_tokens ?? 0);
+      if (used / config.contextWindow >= config.compactAt) {
+        console.log(c.yellow(`  context ${Math.round((used / config.contextWindow) * 100)}% full — compacting`));
+        if (!await compactInto(messages, model, signal)) config.autoCompact = false;
+      }
+    }
+
+    // No tools requested → the turn is finished.
+    if (calls.length === 0) {
+      if (!text.trim()) {
+        // Reasoning models sometimes spend the whole budget thinking and emit no
+        // answer. Say so rather than returning silence.
+        console.log(c.yellow('  (model produced no answer — raise KRONK_MAX_TOKENS or /thinking off)'));
+        messages.push({ role: 'assistant', content: '(no answer produced)' });
+      } else {
+        messages.push({ role: 'assistant', content: text });
+      }
+      return messages;
+    }
+
+    messages.push({
+      role: 'assistant',
+      content: text,
+      tool_calls: calls.map((t) => ({
+        id: t.id, type: 'function',
+        function: { name: t.name, arguments: t.args || '{}' },
+      })),
+    });
+
+    for (const call of calls) {
+      if (signal?.aborted) {
+        messages.push({ role: 'tool', tool_call_id: call.id, content: 'error: interrupted by user' });
+        continue;
+      }
+      let args;
+      try { args = JSON.parse(call.args || '{}'); }
+      catch {
+        messages.push({ role: 'tool', tool_call_id: call.id,
+          content: `error: arguments were not valid JSON: ${call.args}` });
+        continue;
+      }
+
+      const at = Number.isFinite(maxSteps) ? `${step}/${maxSteps}` : `${step}`;
+      const isMcp = Boolean(mcp?.has(call.name));
+      const label = isMcp
+        ? `${c.magenta('⚙')} ${call.name} ${c.grey(JSON.stringify(args).slice(0, 120))}`
+        : `${c.blue(`⚙ ${describe(call.name, args)}`)}`;
+      console.log(`${c.grey(`  ${at}`)} ${label}`);
+
+      if (isMcp ? mcpNeedsApproval(call.name) : NEEDS_APPROVAL.has(call.name)) {
+        const body = preview(call.name, args);
+        if (body) console.log(body.split('\n').map((l) => `    ${l}`).join('\n'));
+        const ok = await approve(call.name, args);
+        if (!ok) {
+          console.log(c.red('  ✗ denied'));
+          messages.push({ role: 'tool', tool_call_id: call.id,
+            content: 'error: the user denied this action. Ask what to do instead.' });
+          continue;
+        }
+      }
+
+      const live = liveLine();
+      let result;
+      try {
+        result = isMcp
+          ? await mcp.call(call.name, args)
+          : await runTool(call.name, args, {
+              onProgress: (info) => live.update({ ...info, window: config.contextWindow }),
+            });
+      } finally {
+        live.done();
+      }
+
+      result = await maybeDistill(result, {
+        model, signal, command: args.cmd ?? describe(call.name, args),
+      });
+      const failed = result.startsWith('error:');
+      console.log(failed
+        ? c.red(`  ✗ ${result.split('\n')[0]}`)
+        : c.grey(`  ✓ ${result.split('\n').length} lines`));
+      messages.push({ role: 'tool', tool_call_id: call.id, content: result });
+    }
+    // loop: the model now sees the tool output
+  }
+}

package/src/client.js

@@ -0,0 +1,115 @@
+import { config, headers } from './config.js';
+import { createSseParser, accumulateToolCalls } from './sse.js';
+
+async function req(path, init = {}) {
+  const res = await fetch(`${config.baseUrl}${path}`, { headers: headers(), ...init });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`${res.status} ${path} — ${body.slice(0, 400)}`);
+  }
+  return res;
+}
+
+export async function listModels() {
+  const { data } = await (await req('/models')).json();
+  return data.map((m) => m.id);
+}
+
+/**
+ * Effective context window for a model id, plus the model's native maximum.
+ * The id contains slashes, so it must be percent-encoded — Kronk's route takes
+ * one path segment and 404s on a raw id.
+ */
+export async function modelLimits(id) {
+  try {
+    const d = await (await req(`/kronk/models/${encodeURIComponent(id)}`)).json();
+    const configured = d.model_config?.['context-window'] ?? null;
+    const nativeKey = Object.keys(d.metadata ?? {}).find((k) => k.endsWith('.context_length'));
+    const native = nativeKey ? Number(d.metadata[nativeKey]) : null;
+    return { configured, native };
+  } catch { return { configured: null, native: null }; }
+}
+
+/** Native Kronk model list: size, projector, validation. */
+export async function listModelDetails() {
+  try {
+    const { data } = await (await req('/kronk/models')).json();
+    return data ?? [];
+  } catch { return []; }
+}
+
+/** Which models are resident in the pool right now, and what they cost. */
+export async function listLoaded() {
+  try {
+    return await (await req('/kronk/models/ps')).json();
+  } catch { return []; }
+}
+
+export async function tokenize(model, input) {
+  try {
+    const r = await (await req('/tokenize', {
+      method: 'POST',
+      body: JSON.stringify({ model, input }),
+    })).json();
+    return r.tokens;
+  } catch {
+    return Math.ceil(input.length / 4);
+  }
+}
+
+/**
+ * Stream a chat completion. Yields:
+ *   {type:'text',      value}
+ *   {type:'reasoning', value}
+ *   {type:'usage',     value}
+ *   {type:'done',      calls, finish}
+ */
+export async function* streamChat({ model, messages, tools, signal, maxTokens, noThink }) {
+  const res = await req('/chat/completions', {
+    method: 'POST',
+    signal,
+    body: JSON.stringify({
+      model,
+      messages,
+      ...(tools?.length ? { tools, tool_choice: 'auto' } : {}),
+      stream: true,
+      stream_options: { include_usage: true },
+      max_completion_tokens: maxTokens,
+      ...(noThink ? { enable_thinking: false } : {}),
+    }),
+  });
+
+  const reader = res.body.getReader();
+  const dec = new TextDecoder();
+  const parser = createSseParser();
+  const calls = new Map();
+  let finish = null;
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    for (const payload of parser.push(dec.decode(value, { stream: true }))) {
+      if (payload === '[DONE]') continue;
+
+      let chunk;
+      try { chunk = JSON.parse(payload); } catch { continue; }
+
+      if (chunk.usage) yield { type: 'usage', value: chunk.usage };
+
+      const choice = chunk.choices?.[0];
+      if (!choice) continue;
+      if (choice.finish_reason) finish = choice.finish_reason;
+
+      const d = choice.delta;
+      if (!d) continue;
+
+      if (d.reasoning_content) yield { type: 'reasoning', value: d.reasoning_content };
+      if (d.content)           yield { type: 'text',      value: d.content };
+
+      accumulateToolCalls(calls, d.tool_calls);
+    }
+  }
+
+  yield { type: 'done', calls: [...calls.values()], finish };
+}

package/src/compact.js

@@ -0,0 +1,108 @@
+import { streamChat, tokenize } from './client.js';
+import { config } from './config.js';
+import { c } from './ui.js';
+
+const PROMPT = `Summarize the conversation above so it can be continued in a fresh context.
+
+Write it for your own future self, not for a human reader. Include, in this order:
+
+1. What the user is trying to achieve, in their words where possible.
+2. Decisions already made, and any the user explicitly rejected.
+3. Files created or modified, with their paths and what each now does.
+4. Commands that were run and what they showed — especially failures.
+5. What is still outstanding.
+
+Be specific: real paths, real function names, real error text. Omit pleasantries and
+anything already superseded. Facts you drop are lost for good.`;
+
+/**
+ * Keep a transcript under `budget` tokens by removing the middle.
+ *
+ * The summarizer runs against the same context window that just overflowed, so
+ * feeding it the whole transcript fails the same way. Head and tail are the
+ * parts worth keeping: the goal is stated at the start, current state at the
+ * end. ~4 chars per token is close enough for a safety margin.
+ */
+function fit(text, budgetTokens) {
+  const cap = budgetTokens * 4;
+  if (text.length <= cap) return { text, elided: 0 };
+  const head = Math.floor(cap * 0.35);
+  const tail = Math.floor(cap * 0.65);
+  const dropped = text.length - head - tail;
+  return {
+    text: `${text.slice(0, head)}\n\n[…${dropped.toLocaleString()} characters elided…]\n\n${text.slice(-tail)}`,
+    elided: dropped,
+  };
+}
+
+/** Flatten a message list into something the model can read back. */
+function transcript(messages) {
+  return messages
+    .filter((m) => m.role !== 'system')
+    .map((m) => {
+      if (m.role === 'tool') return `[tool result]\n${String(m.content).slice(0, 4000)}`;
+      const calls = m.tool_calls?.length
+        ? `\n[called ${m.tool_calls.map((t) => t.function.name).join(', ')}]`
+        : '';
+      return `${m.role}: ${m.content ?? ''}${calls}`;
+    })
+    .join('\n\n');
+}
+
+/**
+ * Replace the conversation with a summary of itself, keeping the system message.
+ *
+ * Tool messages are dropped rather than carried over: they are only valid when
+ * paired with the assistant tool_calls that produced them, and a partial carry
+ * leaves orphaned tool_call_ids that the API rejects.
+ */
+export async function compact(messages, { model, signal } = {}) {
+  const system = messages[0];
+  const raw = transcript(messages);
+  if (!raw.trim()) return { messages, before: 0, after: 0 };
+
+  const before = await tokenize(model, [system.content, raw].join('\n'));
+
+  // Leave room for the instruction and the summary itself.
+  const window = config.contextWindow ?? 32768;
+  const { text: body, elided } = fit(raw, Math.floor(window * 0.6));
+  if (elided) console.log(c.grey(`  transcript too large for one pass — elided ${elided.toLocaleString()} chars from the middle`));
+
+  let summary = '';
+  for await (const ev of streamChat({
+    model,
+    messages: [
+      { role: 'user', content: `${body}\n\n---\n\n${PROMPT}` },
+    ],
+    signal,
+    maxTokens: Math.min(4096, config.maxTokens),
+    noThink: true,
+  })) {
+    if (ev.type === 'text') summary += ev.value;
+  }
+
+  if (!summary.trim()) return { messages, before, after: before, failed: true };
+
+  const next = [
+    system,
+    { role: 'user', content: `[context compacted — summary of the work so far]\n\n${summary.trim()}` },
+    { role: 'assistant', content: 'Understood. Continuing from there.' },
+  ];
+  const after = await tokenize(model, next.map((m) => m.content).join('\n'));
+
+  // A short conversation can summarize to something longer than itself. Keep
+  // the original rather than paying tokens to lose detail.
+  if (after >= before) return { messages, before, after, skipped: true };
+
+  return { messages: next, before, after, summary: summary.trim() };
+}
+
+/** True when an API error is the context-window rejection. */
+export const isOverflow = (e) =>
+  /exceed(s)? context window|context window/i.test(e?.message ?? '');
+
+export function report({ before, after, skipped }) {
+  if (skipped) return c.grey(`  already compact (${before.toLocaleString()} tokens) — left as is`);
+  const pct = Math.round((1 - after / before) * 100);
+  return c.grey(`  compacted ${before.toLocaleString()} → ${after.toLocaleString()} tokens (−${pct}%)`);
+}

package/src/config.js

@@ -0,0 +1,41 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+
+const RC = join(homedir(), '.kronk-cli.json');
+
+function fileConfig() {
+  try { return JSON.parse(readFileSync(RC, 'utf8')); } catch { return {}; }
+}
+
+const file = fileConfig();
+
+/** Used when nothing is passed on the command line or in the environment. */
+export const DEFAULT_MODEL = 'unsloth/Qwen3.6-35B-A3B-UD-Q4_K_M/AGENT';
+
+export const config = {
+  baseUrl: process.env.KRONK_URL   ?? file.baseUrl ?? 'http://localhost:11435/v1',
+  token:   process.env.KRONK_TOKEN ?? file.token   ?? 'kronk',
+  model:   process.env.KRONK_MODEL ?? file.model   ?? null,   // null → DEFAULT_MODEL, then auto-pick
+  maxTokens: Number(process.env.KRONK_MAX_TOKENS ?? file.maxTokens ?? 8192),
+  // Unlimited by default — a run stops when the model is done or you press Ctrl-C.
+  // Set --steps / KRONK_MAX_STEPS to opt into a cap.
+  maxSteps: Number(process.env.KRONK_MAX_STEPS ?? file.maxSteps ?? Infinity),
+  showThinking: (process.env.KRONK_THINKING ?? String(file.showThinking ?? 'true')) !== 'false',
+  noThink: (process.env.KRONK_NO_THINK ?? String(file.noThink ?? '')) === '1',
+  autoCompact: (process.env.KRONK_AUTO_COMPACT ?? String(file.autoCompact ?? 'true')) !== 'false',
+  compactAt: Number(process.env.KRONK_COMPACT_AT ?? file.compactAt ?? 0.85),
+  // Large tool output is summarized in a throwaway context so the raw text
+  // never enters the conversation. Set KRONK_DISTILL=false to keep it whole.
+  distill: (process.env.KRONK_DISTILL ?? String(file.distill ?? 'true')) !== 'false',
+  distillAt: Number(process.env.KRONK_DISTILL_AT ?? file.distillAt ?? 8000),
+  lastUsed: 0,
+  contextWindow: null,   // filled in at boot from Kronk
+  nativeContext: null,
+  rcPath: RC,
+};
+
+export const headers = () => ({
+  'Content-Type': 'application/json',
+  Authorization: `Bearer ${config.token}`,
+});

package/src/context.js

@@ -0,0 +1,95 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { join } from 'node:path';
+
+const exec = promisify(execFile);
+
+/** Files that, by convention, tell an agent how to work in this repo. */
+const AGENT_FILES = ['AGENTS.md', 'CLAUDE.md', 'KRONK.md', '.cursorrules', 'CONVENTIONS.md'];
+const AGENT_FILE_CAP = 6000;
+const LISTING_CAP = 60;
+
+const SKIP = new Set([
+  'node_modules', '.git', 'dist', 'build', 'out', 'target', 'vendor',
+  '.next', '.venv', '__pycache__', '.DS_Store', 'coverage', '.turbo',
+]);
+
+async function sh(cmd, args, cwd) {
+  try {
+    const { stdout } = await exec(cmd, args, { cwd, timeout: 5000 });
+    return stdout.trim();
+  } catch { return ''; }
+}
+
+async function gitContext(cwd) {
+  const inside = await sh('git', ['rev-parse', '--is-inside-work-tree'], cwd);
+  if (inside !== 'true') return null;
+
+  const [branch, status, recent] = await Promise.all([
+    sh('git', ['rev-parse', '--abbrev-ref', 'HEAD'], cwd),
+    sh('git', ['status', '--porcelain'], cwd),
+    sh('git', ['log', '-5', '--oneline', '--no-decorate'], cwd),
+  ]);
+
+  const changed = status ? status.split('\n').filter(Boolean) : [];
+  return {
+    branch,
+    dirty: changed.length,
+    changed: changed.slice(0, 20),
+    recent: recent ? recent.split('\n') : [],
+  };
+}
+
+async function listing(cwd) {
+  let names;
+  try { names = await readdir(cwd); } catch { return []; }
+  const kept = names.filter((n) => !SKIP.has(n) && !n.startsWith('.git'));
+  const rows = await Promise.all(kept.slice(0, LISTING_CAP).map(async (n) => {
+    try { return (await stat(join(cwd, n))).isDirectory() ? `${n}/` : n; }
+    catch { return n; }
+  }));
+  rows.sort();
+  if (kept.length > LISTING_CAP) rows.push(`…and ${kept.length - LISTING_CAP} more`);
+  return rows;
+}
+
+async function agentFile(cwd) {
+  for (const name of AGENT_FILES) {
+    try {
+      const body = await readFile(join(cwd, name), 'utf8');
+      if (!body.trim()) continue;
+      const clipped = body.length > AGENT_FILE_CAP
+        ? `${body.slice(0, AGENT_FILE_CAP)}\n…[truncated]`
+        : body;
+      return { name, body: clipped };
+    } catch { /* next */ }
+  }
+  return null;
+}
+
+/**
+ * A short primer describing where the agent is standing, gathered once at
+ * startup. Saves the model a round trip and stops it guessing about layout.
+ */
+export async function projectContext(cwd = process.cwd()) {
+  const [files, git, agents] = await Promise.all([listing(cwd), gitContext(cwd), agentFile(cwd)]);
+
+  const parts = [`Working directory: ${cwd}`, `Platform: ${process.platform}`];
+
+  if (git) {
+    parts.push(`Git: branch ${git.branch}, ${git.dirty} uncommitted change(s)`);
+    if (git.changed.length) parts.push(`Modified:\n${git.changed.map((l) => `  ${l}`).join('\n')}`);
+    if (git.recent.length) parts.push(`Recent commits:\n${git.recent.map((l) => `  ${l}`).join('\n')}`);
+  } else {
+    parts.push('Git: not a repository');
+  }
+
+  if (files.length) parts.push(`Top level:\n${files.map((f) => `  ${f}`).join('\n')}`);
+
+  if (agents) {
+    parts.push(`Project instructions from ${agents.name} — follow these:\n\n${agents.body}`);
+  }
+
+  return { text: parts.join('\n\n'), agentFile: agents?.name ?? null, isGit: Boolean(git) };
+}