@thispointon/kondi-chat 0.1.2

package/src/session/store.ts

@@ -0,0 +1,211 @@
+/**
+ * Session persistence — save/load sessions under `.kondi-chat/sessions/`.
+ *
+ * Single SessionStore. Two constants (AUTO_SAVE_MS, MAX_AGE_DAYS). Atomic
+ * writes via temp+rename. The ledger files stay flat in storageDir as they
+ * are today — see specs/06-session-resume/SPEC.md for the rationale.
+ */
+
+import {
+  existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync,
+  renameSync, rmSync, statSync, unlinkSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
+import type { Session } from '../types.ts';
+
+export const AUTO_SAVE_MS = 30_000;
+export const MAX_AGE_DAYS = 30;
+const MAX_AGE_MS = MAX_AGE_DAYS * 24 * 60 * 60 * 1000;
+
+export interface PersistedSession {
+  version: 1;
+  session: Session;
+  activeProfile: string;
+  overrideModel?: string;
+  lastSavedAt: string;
+  workingDirectory: string;
+}
+
+export interface SessionIndexEntry {
+  id: string;
+  createdAt: string;
+  updatedAt: string;
+  workingDirectory: string;
+  messageCount: number;
+  totalCostUsd: number;
+  activeModel?: string;
+  profile: string;
+  summary: string;
+}
+
+function atomicWrite(path: string, data: string): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = path + '.tmp';
+  writeFileSync(tmp, data);
+  try { renameSync(tmp, path); } catch { writeFileSync(path, data); }
+}
+
+export class SessionStore {
+  private sessionsDir: string;
+  private indexPath: string;
+  private activePath: string;
+  private index: SessionIndexEntry[];
+
+  constructor(storageDir: string) {
+    this.sessionsDir = join(storageDir, 'sessions');
+    this.indexPath = join(this.sessionsDir, 'index.json');
+    this.activePath = join(this.sessionsDir, 'active.json');
+    mkdirSync(this.sessionsDir, { recursive: true });
+    this.index = this.loadIndex();
+  }
+
+  save(session: Session, profile: string, overrideModel?: string): void {
+    const persisted: PersistedSession = {
+      version: 1,
+      session,
+      activeProfile: profile,
+      overrideModel,
+      lastSavedAt: new Date().toISOString(),
+      workingDirectory: session.workingDirectory || '',
+    };
+    atomicWrite(
+      join(this.sessionsDir, `${session.id}.json`),
+      JSON.stringify(persisted, null, 2),
+    );
+    this.updateIndex({
+      id: session.id,
+      createdAt: session.createdAt,
+      updatedAt: new Date().toISOString(),
+      workingDirectory: session.workingDirectory || '',
+      messageCount: session.messages.length,
+      totalCostUsd: session.totalCostUsd,
+      activeModel: session.activeModel,
+      profile,
+      summary: this.computeSummary(session),
+    });
+  }
+
+  load(idOrPrefix: string): PersistedSession | null {
+    const id = this.resolveId(idOrPrefix);
+    if (!id) return null;
+    const file = join(this.sessionsDir, `${id}.json`);
+    if (!existsSync(file)) return null;
+    try {
+      return JSON.parse(readFileSync(file, 'utf-8')) as PersistedSession;
+    } catch {
+      return null;
+    }
+  }
+
+  loadLatest(workingDirectory?: string): PersistedSession | null {
+    const entries = this.list(workingDirectory);
+    if (entries.length === 0) return null;
+    return this.load(entries[0].id);
+  }
+
+  list(workingDirectory?: string): SessionIndexEntry[] {
+    const entries = workingDirectory
+      ? this.index.filter(e => e.workingDirectory === workingDirectory)
+      : [...this.index];
+    return entries.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+  }
+
+  delete(id: string): void {
+    const resolved = this.resolveId(id) || id;
+    const file = join(this.sessionsDir, `${resolved}.json`);
+    if (existsSync(file)) { try { unlinkSync(file); } catch { /* ignore */ } }
+    this.index = this.index.filter(e => e.id !== resolved);
+    this.saveIndex();
+  }
+
+  /** Delete sessions older than MAX_AGE_DAYS. Returns count removed. */
+  cleanup(): { deleted: number } {
+    const cutoff = Date.now() - MAX_AGE_MS;
+    let deleted = 0;
+    for (const entry of [...this.index]) {
+      const updated = new Date(entry.updatedAt).getTime();
+      if (!isFinite(updated) || updated < cutoff) {
+        this.delete(entry.id);
+        deleted++;
+      }
+    }
+    return { deleted };
+  }
+
+  setActive(id: string): void {
+    atomicWrite(this.activePath, JSON.stringify({ id }));
+  }
+
+  getActive(): string | null {
+    if (!existsSync(this.activePath)) return null;
+    try { return JSON.parse(readFileSync(this.activePath, 'utf-8')).id || null; }
+    catch { return null; }
+  }
+
+  format(workingDirectory?: string): string {
+    const entries = this.list(workingDirectory);
+    if (entries.length === 0) return 'No sessions yet.';
+    const lines = ['Sessions (newest first):'];
+    for (const e of entries.slice(0, 20)) {
+      lines.push(
+        `  ${e.id.slice(0, 8)}  ${e.updatedAt.slice(0, 19)}  ${e.messageCount}msg  $${e.totalCostUsd.toFixed(4)}`
+        + (e.summary ? `\n    ${e.summary}` : ''),
+      );
+    }
+    if (entries.length > 20) lines.push(`  ... and ${entries.length - 20} more`);
+    return lines.join('\n');
+  }
+
+  /** Match by exact id, or ≥8-char prefix when unambiguous. */
+  private resolveId(idOrPrefix: string): string | null {
+    if (this.index.some(e => e.id === idOrPrefix)) return idOrPrefix;
+    if (idOrPrefix.length < 8) return null;
+    const matches = this.index.filter(e => e.id.startsWith(idOrPrefix));
+    return matches.length === 1 ? matches[0].id : null;
+  }
+
+  private updateIndex(entry: SessionIndexEntry): void {
+    const existing = this.index.findIndex(e => e.id === entry.id);
+    if (existing >= 0) this.index[existing] = entry;
+    else this.index.push(entry);
+    this.saveIndex();
+  }
+
+  private loadIndex(): SessionIndexEntry[] {
+    if (!existsSync(this.indexPath)) return [];
+    try {
+      const raw = JSON.parse(readFileSync(this.indexPath, 'utf-8'));
+      return Array.isArray(raw?.sessions) ? raw.sessions : [];
+    } catch { return []; }
+  }
+
+  private saveIndex(): void {
+    atomicWrite(this.indexPath, JSON.stringify({ sessions: this.index }, null, 2));
+  }
+
+  /** Spec 13 — save in-progress assistant content so a crash leaves a recoverable trail. */
+  savePartialMessage(sessionId: string, content: string): void {
+    const dir = join(this.sessionsDir, '..', 'recovery');
+    const path = join(dir, `${sessionId}-partial.json`);
+    atomicWrite(path, JSON.stringify({ sessionId, content, savedAt: new Date().toISOString() }));
+  }
+
+  /** Spec 13 — read any partial from a prior run; null if none. */
+  checkForRecovery(sessionId: string): { content: string; savedAt: string } | null {
+    const path = join(this.sessionsDir, '..', 'recovery', `${sessionId}-partial.json`);
+    if (!existsSync(path)) return null;
+    try { return JSON.parse(readFileSync(path, 'utf-8')); } catch { return null; }
+  }
+
+  /** Delete the partial file once the session has integrated it. */
+  clearRecovery(sessionId: string): void {
+    const path = join(this.sessionsDir, '..', 'recovery', `${sessionId}-partial.json`);
+    if (existsSync(path)) { try { unlinkSync(path); } catch { /* ignore */ } }
+  }
+
+  private computeSummary(session: Session): string {
+    if (session.state.goal) return session.state.goal.slice(0, 120);
+    const firstUser = session.messages.find(m => m.role === 'user');
+    return firstUser ? firstUser.content.slice(0, 120) : '';
+  }
+}

package/src/test-utils/mock-llm.ts

@@ -0,0 +1,39 @@
+/**
+ * Minimal Mock LLM for tests.
+ *
+ * Pass a pre-canned queue of LLMResponses; each call dequeues the next.
+ * Tests that exercise multi-turn tool loops can enqueue the full sequence.
+ */
+
+import type { LLMRequest, LLMResponse } from '../types.ts';
+
+export interface MockLLMOptions {
+  responses: Array<Partial<LLMResponse>>;
+}
+
+export interface MockLLM {
+  call: (req: LLMRequest) => Promise<LLMResponse>;
+  calls: LLMRequest[];
+}
+
+export function createMockLLM(opts: MockLLMOptions): MockLLM {
+  const queue = [...opts.responses];
+  const calls: LLMRequest[] = [];
+  return {
+    calls,
+    async call(req: LLMRequest): Promise<LLMResponse> {
+      calls.push(req);
+      const next = queue.shift();
+      if (!next) throw new Error('Mock LLM: no more responses queued');
+      return {
+        content: next.content ?? '',
+        model: next.model ?? req.model ?? 'mock',
+        provider: next.provider ?? req.provider ?? 'anthropic',
+        inputTokens: next.inputTokens ?? 10,
+        outputTokens: next.outputTokens ?? 20,
+        latencyMs: next.latencyMs ?? 1,
+        toolCalls: next.toolCalls,
+      };
+    },
+  };
+}

package/src/types.ts

@@ -0,0 +1,322 @@
+/**
+ * Core types for kondi-chat
+ */
+
+// ---------------------------------------------------------------------------
+// Provider & Model
+// ---------------------------------------------------------------------------
+
+export type ProviderId =
+  | 'anthropic'
+  | 'openai'
+  | 'deepseek'
+  | 'google'
+  | 'xai'
+  | 'zai'
+  | 'ollama'
+  | 'nvidia-router';
+
+export interface ProviderConfig {
+  id: ProviderId;
+  apiKey?: string;
+  baseUrl?: string;
+  defaultModel?: string;
+}
+
+export interface ModelInfo {
+  id: string;
+  provider: ProviderId;
+  contextWindow: number;
+  maxOutputTokens: number;
+  inputCostPer1M: number;
+  outputCostPer1M: number;
+  supportsCaching?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Messages
+// ---------------------------------------------------------------------------
+
+export interface Message {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+  timestamp: string;
+  model?: string;
+  provider?: ProviderId;
+  tokenCount?: number;
+  inputTokens?: number;
+  outputTokens?: number;
+}
+
+// ---------------------------------------------------------------------------
+// Repo Map — structured codebase summary, created once per repo
+// ---------------------------------------------------------------------------
+
+export interface RepoMap {
+  stack: string[];
+  entrypoints: string[];
+  subsystems: Array<{ name: string; paths: string[]; purpose: string }>;
+  commands: { build?: string; test?: string; lint?: string; typecheck?: string };
+  conventions: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Session State — durable conversation memory
+// ---------------------------------------------------------------------------
+
+export interface SessionState {
+  goal: string;
+  decisions: string[];
+  constraints: string[];
+  currentPlan: string[];
+  activeTaskId?: string;
+  recentFailures: string[];
+  lastUpdatedAtTurn: number;
+}
+
+// ---------------------------------------------------------------------------
+// Task Card — bounded work packet for execution
+// ---------------------------------------------------------------------------
+
+/**
+ * Task kinds are open-ended. Defaults: implementation, fix, refactor, test, analysis.
+ * Users/plugins can add domain-specific kinds: robot-control, image-generation, etc.
+ * The router learns to route new kinds through training data.
+ */
+export type TaskKind = string;
+
+export interface TaskCard {
+  id: string;
+  kind: TaskKind;
+  goal: string;
+  relevantFiles: string[];
+  constraints: string[];
+  acceptanceCriteria: string[];
+  outputMode: 'diff' | 'file_replacements' | 'text';
+  failures: number;
+  createdAt: string;
+  completedAt?: string;
+  status: 'pending' | 'executing' | 'verifying' | 'passed' | 'failed' | 'promoted';
+}
+
+// ---------------------------------------------------------------------------
+// Creative Generation
+// ---------------------------------------------------------------------------
+
+export interface CreativeGenerationRequest {
+  description: string;
+  images?: string[]; // Base64 encoded images
+  style?: string; // e.g., "technical", "narrative", "visual", etc.
+  constraints?: string[]; // Any specific requirements
+}
+
+export interface CreativeGenerationResponse {
+  content: string; // The generated creative content
+  type: 'text' | 'code' | 'structured' | 'mixed';
+  metadata?: {
+    model: string;
+    tokens?: number;
+    confidence?: number;
+    suggestions?: string[]; // Additional ideas or variations
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Verification
+// ---------------------------------------------------------------------------
+
+export interface VerificationResult {
+  passed: boolean;
+  testOutput?: string;
+  lintOutput?: string;
+  typecheckOutput?: string;
+  error?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Audit Ledger — every LLM call recorded
+// ---------------------------------------------------------------------------
+
+export type LedgerPhase =
+  | 'consult'          // consultant expert — domain-specialized persona
+  | 'discuss'          // frontier: user conversation
+  | 'commit'           // system: state update
+  | 'dispatch'         // frontier: task card creation
+  | 'execute'          // worker: code generation
+  | 'verify'           // local: tests/lint/typecheck
+  | 'reflect'          // frontier: summarize results
+  | 'compress'         // cheap: context compression
+  | 'state_update';    // cheap: working state update
+
+export interface LedgerEntry {
+  id: string;
+  timestamp: string;
+  phase: LedgerPhase;
+  provider: ProviderId;
+  model: string;
+  inputTokens: number;
+  outputTokens: number;
+  latencyMs: number;
+  costUsd: number;
+  cached: boolean;
+  /** Input tokens served from the provider's prompt cache (included in inputTokens). */
+  cachedInputTokens?: number;
+
+  /** What was sent (system + user prompt) */
+  promptSummary: string;
+  /** What came back */
+  responseSummary: string;
+
+  /** Associated task card ID, if any */
+  taskId?: string;
+  /** Was this a promotion (retry with better model)? */
+  promoted?: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Session
+// ---------------------------------------------------------------------------
+
+export interface Session {
+  id: string;
+  createdAt: string;
+  workingDirectory?: string;
+
+  /** Full message history — never truncated, used for export/replay */
+  messages: Message[];
+
+  /** Durable session state */
+  state: SessionState;
+
+  /** Repo map — structured codebase summary */
+  repoMap?: RepoMap;
+
+  /** Raw grounding context for prompt assembly */
+  groundingContext?: string;
+
+  /** All task cards created during this session */
+  tasks: TaskCard[];
+
+  /** Active provider/model (can change mid-session) */
+  activeProvider: ProviderId;
+  activeModel?: string;
+
+  /** Cumulative cost tracking */
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCostUsd: number;
+}
+
+// ---------------------------------------------------------------------------
+// Context Budget
+// ---------------------------------------------------------------------------
+
+export interface ContextSection {
+  key: string;
+  content: string;
+  priority: number;
+  compressible: boolean;
+  tokenEstimate: number;
+}
+
+// ---------------------------------------------------------------------------
+// Tool Use
+// ---------------------------------------------------------------------------
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>; // JSON Schema
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface ToolResult {
+  toolCallId: string;
+  content: string;
+  isError?: boolean;
+  /** Spec 03 — unified diff, when the tool mutated a file. */
+  diff?: string;
+}
+
+// ---------------------------------------------------------------------------
+// LLM Call — multi-turn message for agent loops
+// ---------------------------------------------------------------------------
+
+/** Spec 09 — multimodal content part. Text remains the default. */
+export type ContentPart =
+  | { type: 'text'; text: string }
+  | { type: 'image'; mimeType: string; base64: string };
+
+export interface LLMMessage {
+  role: 'user' | 'assistant' | 'tool';
+  content?: string;
+  /** Hidden chain-of-thought from reasoning models. Must be passed back
+   *  to some providers (DeepSeek) in multi-turn conversations. */
+  reasoningContent?: string;
+  /** Spec 09 — interleaved text/image parts; providers that support it use this. */
+  parts?: ContentPart[];
+  toolCalls?: ToolCall[];     // assistant messages with tool use
+  toolResults?: ToolResult[]; // tool-result messages
+}
+
+/** Spec 09 — image attachment descriptor (used by submit command + pipeline). */
+export interface ImageAttachment {
+  mimeType: string;
+  base64: string;
+  originalPath?: string;
+  sizeBytes: number;
+}
+
+export interface LLMRequest {
+  provider: ProviderId;
+  model?: string;
+  systemPrompt: string;
+  /** Simple single-turn: set userMessage */
+  userMessage?: string;
+  /** Multi-turn agent loop: set messages instead */
+  messages?: LLMMessage[];
+  tools?: ToolDefinition[];
+  maxOutputTokens?: number;
+  temperature?: number;
+  cacheablePrefix?: string;
+  /** Stream the response token by token */
+  stream?: boolean;
+  /** Callback for each streamed token chunk */
+  onToken?: (token: string) => void;
+}
+
+export interface LLMResponse {
+  content: string;
+  model: string;
+  provider: ProviderId;
+  inputTokens: number;
+  outputTokens: number;
+  latencyMs: number;
+  cached?: boolean;
+  toolCalls?: ToolCall[];
+  /** True if this response came from a fallback model, not the originally requested one */
+  wasFallback?: boolean;
+  /** The originally requested model (if different from the responding model) */
+  requestedModel?: string;
+  /** Spec 14 — raw response headers for rate-limit parsing. */
+  responseHeaders?: Record<string, string>;
+  /**
+   * Hidden chain-of-thought emitted by reasoning models (GLM-5.x, OpenAI o-series,
+   * DeepSeek-R1, Anthropic extended thinking). Billed as output tokens but not
+   * shown inline; the TUI exposes it via Ctrl+R.
+   */
+  reasoningContent?: string;
+  /**
+   * Portion of inputTokens that the provider served from its prompt cache
+   * (OpenAI `prompt_tokens_details.cached_tokens`, Anthropic
+   * `cache_read_input_tokens`). Billed at reduced rate — our cost estimate
+   * subtracts 50% of the standard input price on the cached portion, which
+   * matches the published discount on both OpenAI and Z.AI endpoints.
+   */
+  cachedInputTokens?: number;
+}