@thispointon/kondi-chat 0.1.2

package/src/council-engine/cli/llm-caller.ts

@@ -0,0 +1,229 @@
+/**
+ * LLM Router — API Only
+ *
+ * All providers use direct HTTP calls. No CLI binaries, no sandboxes.
+ * Requires API keys set as environment variables or in .env file.
+ */
+
+export interface CallerResult {
+  content: string;
+  tokensUsed: number;
+  latencyMs: number;
+  sessionId?: string;
+}
+
+interface CallLLMOpts {
+  provider: string;
+  model?: string;
+  systemPrompt: string;
+  userMessage: string;
+  workingDir?: string;
+  skipTools?: boolean;
+  timeoutMs?: number;
+  /** Stable context that can be cached (Anthropic prompt caching) */
+  cacheableContext?: string;
+  /** Max output tokens (defaults to 16384) */
+  maxOutputTokens?: number;
+}
+
+export const DEFAULT_MODELS: Record<string, string> = {
+  'anthropic-api': 'claude-sonnet-4-5-20250929',
+  'openai-api': 'gpt-4o',
+  'deepseek': 'deepseek-chat',
+  'google': 'models/gemini-2.5-flash',
+  'xai': 'grok-3',
+  'ollama': 'llama3.1',
+};
+
+function getApiKey(provider: string): string | undefined {
+  switch (provider) {
+    case 'anthropic-api': return process.env.ANTHROPIC_API_KEY;
+    case 'openai-api': return process.env.OPENAI_API_KEY;
+    case 'deepseek': return process.env.DEEPSEEK_API_KEY;
+    case 'xai': return process.env.XAI_API_KEY;
+    case 'google': return process.env.GOOGLE_API_KEY;
+    default: return undefined;
+  }
+}
+
+// ============================================================================
+// Provider implementations
+// ============================================================================
+
+async function callAnthropicAPI(
+  apiKey: string,
+  model: string,
+  systemPrompt: string,
+  userMessage: string,
+  cacheableContext?: string,
+  maxOutputTokens = 16384,
+): Promise<CallerResult> {
+  const start = Date.now();
+
+  // Build system content with optional prompt caching
+  const systemContent: Array<{ type: string; text: string; cache_control?: { type: string } }> = [];
+  if (cacheableContext) {
+    systemContent.push({
+      type: 'text',
+      text: cacheableContext,
+      cache_control: { type: 'ephemeral' },
+    });
+  }
+  systemContent.push({ type: 'text', text: systemPrompt });
+
+  const resp = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'anthropic-version': '2023-06-01',
+      'anthropic-beta': 'prompt-caching-2024-07-31',
+      'x-api-key': apiKey,
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxOutputTokens,
+      system: systemContent,
+      messages: [{ role: 'user', content: userMessage }],
+    }),
+  });
+
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`Anthropic API ${resp.status}: ${text.substring(0, 500)}`);
+  }
+
+  const data = await resp.json();
+  const content = data.content
+    ?.filter((b: any) => b.type === 'text')
+    .map((b: any) => b.text)
+    .join('\n') || '';
+  const usage = data.usage || {};
+
+  return {
+    content,
+    tokensUsed: (usage.input_tokens || 0) + (usage.output_tokens || 0),
+    latencyMs: Date.now() - start,
+  };
+}
+
+async function callOpenAICompatible(
+  baseUrl: string,
+  apiKey: string,
+  model: string,
+  systemPrompt: string,
+  userMessage: string,
+  maxOutputTokens = 16384,
+): Promise<CallerResult> {
+  const start = Date.now();
+
+  const resp = await fetch(`${baseUrl}/chat/completions`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      messages: [
+        { role: 'system', content: systemPrompt },
+        { role: 'user', content: userMessage },
+      ],
+      max_tokens: maxOutputTokens,
+    }),
+  });
+
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`OpenAI API ${resp.status}: ${text.substring(0, 500)}`);
+  }
+
+  const data = await resp.json();
+  const content = data.choices?.[0]?.message?.content || '';
+  const usage = data.usage || {};
+
+  return {
+    content,
+    tokensUsed: (usage.prompt_tokens || 0) + (usage.completion_tokens || 0),
+    latencyMs: Date.now() - start,
+  };
+}
+
+async function callGeminiAPI(
+  apiKey: string,
+  model: string,
+  systemPrompt: string,
+  userMessage: string,
+): Promise<CallerResult> {
+  const start = Date.now();
+
+  const resp = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/${model}:generateContent?key=${apiKey}`,
+    {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        system_instruction: { parts: [{ text: systemPrompt }] },
+        contents: [{ role: 'user', parts: [{ text: userMessage }] }],
+        generationConfig: { maxOutputTokens: 16384 },
+      }),
+    },
+  );
+
+  if (!resp.ok) {
+    const text = await resp.text();
+    throw new Error(`Gemini API ${resp.status}: ${text.substring(0, 500)}`);
+  }
+
+  const data = await resp.json();
+  const content = data.candidates?.[0]?.content?.parts
+    ?.map((p: any) => p.text)
+    .join('\n') || '';
+  const usage = data.usageMetadata || {};
+
+  return {
+    content,
+    tokensUsed: (usage.promptTokenCount || 0) + (usage.candidatesTokenCount || 0),
+    latencyMs: Date.now() - start,
+  };
+}
+
+// ============================================================================
+// Unified router
+// ============================================================================
+
+export async function callLLM(opts: CallLLMOpts): Promise<CallerResult> {
+  const provider = opts.provider || 'anthropic-api';
+  const model = opts.model || DEFAULT_MODELS[provider] || 'claude-sonnet-4-5-20250929';
+
+  const apiKey = getApiKey(provider);
+  if (!apiKey && provider !== 'ollama') {
+    const envVar = provider === 'anthropic-api' ? 'ANTHROPIC_API_KEY'
+      : provider === 'openai-api' ? 'OPENAI_API_KEY'
+      : provider === 'deepseek' ? 'DEEPSEEK_API_KEY'
+      : provider === 'xai' ? 'XAI_API_KEY'
+      : provider === 'google' ? 'GOOGLE_API_KEY'
+      : 'API_KEY';
+    throw new Error(`No API key for "${provider}". Set ${envVar} in environment or .env file.`);
+  }
+
+  if (provider === 'anthropic-api') {
+    return callAnthropicAPI(apiKey!, model, opts.systemPrompt, opts.userMessage, opts.cacheableContext, opts.maxOutputTokens);
+  }
+  if (provider === 'openai-api') {
+    return callOpenAICompatible('https://api.openai.com/v1', apiKey!, model, opts.systemPrompt, opts.userMessage, opts.maxOutputTokens);
+  }
+  if (provider === 'deepseek') {
+    return callOpenAICompatible('https://api.deepseek.com/v1', apiKey!, model, opts.systemPrompt, opts.userMessage, opts.maxOutputTokens);
+  }
+  if (provider === 'xai') {
+    return callOpenAICompatible('https://api.x.ai/v1', apiKey!, model, opts.systemPrompt, opts.userMessage, opts.maxOutputTokens);
+  }
+  if (provider === 'google') {
+    return callGeminiAPI(apiKey!, model, opts.systemPrompt, opts.userMessage);
+  }
+  if (provider === 'ollama') {
+    return callOpenAICompatible('http://localhost:11434/v1', 'ollama', model, opts.systemPrompt, opts.userMessage);
+  }
+
+  throw new Error(`Unknown provider "${provider}". Supported: anthropic-api, openai-api, deepseek, xai, google, ollama`);
+}

package/src/council-engine/cli/localStorage-shim.ts

@@ -0,0 +1,119 @@
+/**
+ * File-backed localStorage polyfill for CLI mode.
+ * Must be imported BEFORE any store modules that use localStorage.
+ *
+ * Persists all state to a JSON file so execution data (councils, personas,
+ * step artifacts, deliberation logs) survives after the CLI run finishes.
+ *
+ * Default location: ~/.local/share/kondi/cli-state/localStorage.json
+ * Override with KONDI_CLI_STATE_DIR env var.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const STATE_DIR = process.env.KONDI_CLI_STATE_DIR
+  || path.join(os.homedir(), '.local', 'share', 'kondi', 'cli-state');
+
+const STATE_FILE = path.join(STATE_DIR, 'localStorage.json');
+
+function ensureDir() {
+  if (!fs.existsSync(STATE_DIR)) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+
+function loadFromDisk(): Record<string, string> {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      const raw = fs.readFileSync(STATE_FILE, 'utf-8');
+      return JSON.parse(raw);
+    }
+  } catch (err) {
+    console.error('[localStorage-shim] Failed to load state file, starting fresh:', err);
+  }
+  return {};
+}
+
+function saveToDisk(data: Record<string, string>) {
+  try {
+    ensureDir();
+    fs.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2), 'utf-8');
+  } catch (err) {
+    console.warn('[localStorage-shim] WARNING: Failed to save state file — data may be lost:', err);
+  }
+}
+
+class FileBackedStorage implements Storage {
+  private data: Record<string, string>;
+  private dirty = false;
+  private flushTimer: ReturnType<typeof setTimeout> | null = null;
+
+  constructor() {
+    ensureDir();
+    this.data = loadFromDisk();
+  }
+
+  get length(): number {
+    return Object.keys(this.data).length;
+  }
+
+  key(index: number): string | null {
+    return Object.keys(this.data)[index] ?? null;
+  }
+
+  getItem(key: string): string | null {
+    return this.data[key] ?? null;
+  }
+
+  setItem(key: string, value: string): void {
+    this.data[key] = String(value);
+    this.scheduleSave();
+  }
+
+  removeItem(key: string): void {
+    delete this.data[key];
+    this.scheduleSave();
+  }
+
+  clear(): void {
+    this.data = {};
+    this.scheduleSave();
+  }
+
+  /** Debounced save — writes at most every 500ms to avoid thrashing disk */
+  private scheduleSave(): void {
+    this.dirty = true;
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flush();
+        this.flushTimer = null;
+      }, 500);
+    }
+  }
+
+  /** Force an immediate write to disk */
+  flush(): void {
+    if (this.dirty) {
+      saveToDisk(this.data);
+      this.dirty = false;
+    }
+  }
+
+  /** Get all data (for export/reporting) */
+  getAll(): Record<string, string> {
+    return { ...this.data };
+  }
+}
+
+// Install globally before any module reads localStorage
+const storage = new FileBackedStorage();
+(globalThis as any).localStorage = storage;
+
+// Flush on process exit so nothing is lost
+process.on('exit', () => storage.flush());
+process.on('SIGINT', () => { storage.flush(); process.exit(130); });
+process.on('SIGTERM', () => { storage.flush(); process.exit(143); });
+
+export { storage };

package/src/council-engine/cli/node-platform.ts

@@ -0,0 +1,68 @@
+/**
+ * Node.js PlatformAdapter implementation for CLI mode.
+ * Uses fs and child_process instead of Tauri invoke.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import type { PlatformAdapter } from '../pipeline/executor';
+
+function assertSafePath(filePath: string, workingDir: string): void {
+  const resolved = path.resolve(filePath);
+  const base = path.resolve(workingDir);
+  if (!resolved.startsWith(base + path.sep) && resolved !== base) {
+    throw new Error(`Path traversal blocked: ${filePath} escapes working directory ${workingDir}`);
+  }
+}
+
+export function createNodePlatform(initialWorkingDir: string): PlatformAdapter {
+  let workingDir = initialWorkingDir;
+
+  return {
+    async writeFile(filePath: string, content: string): Promise<void> {
+      assertSafePath(filePath, workingDir);
+      const dir = path.dirname(filePath);
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(filePath, content, 'utf-8');
+    },
+
+    async readFile(filePath: string): Promise<string | null> {
+      assertSafePath(filePath, workingDir);
+      try {
+        return fs.readFileSync(filePath, 'utf-8');
+      } catch {
+        return null;
+      }
+    },
+
+    async runCommand(cmd: string, cwd: string): Promise<{ stdout: string; stderr: string; exit_code: number; success: boolean }> {
+      try {
+        const stdout = execFileSync('/bin/sh', ['-c', cmd], {
+          cwd,
+          encoding: 'utf-8',
+          timeout: 300_000, // 5 minute timeout for test commands
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { stdout, stderr: '', exit_code: 0, success: true };
+      } catch (err: any) {
+        return {
+          stdout: err.stdout || '',
+          stderr: err.stderr || err.message || '',
+          exit_code: err.status ?? 1,
+          success: false,
+        };
+      }
+    },
+
+    setWorkingDir(dir: string): void {
+      workingDir = dir;
+    },
+
+    getWorkingDir(): string {
+      return workingDir;
+    },
+
+    // saveDeliberationOutput is optional in CLI — files are written directly via writeFile
+  };
+}