savant-code 0.0.19 → 0.0.20

package/packages/database/src/service.ts

@@ -1,342 +0,0 @@
-import crypto from 'crypto'
-
-import { db } from './index'
-
-// Types
-export interface Session {
-  id: string
-  chat_id: string
-  agent_id: string
-  selected_model: string
-  session_state: Record<string, unknown>
-  status: string
-  created_at: string
-  updated_at: string
-}
-
-export interface AgentTemplate {
-  id: string
-  template: Record<string, unknown>
-  version: number
-  created_at: string
-  updated_at: string
-}
-
-export interface FidDocument {
-  id: string
-  session_id: string
-  content: string
-  status: string
-  perfection_loop_phase: string
-  created_at: string
-  updated_at: string
-}
-
-export interface MessageHistory {
-  id: string
-  session_id: string
-  role: string
-  content: unknown
-  created_at: string
-}
-
-/**
- * Parses a stored JSON string, returning `fallback` for corrupt/missing data
- * instead of throwing (FID-006 DB5).
- */
-function parseStoredJson<T>(raw: unknown, fallback: T): T {
-  if (typeof raw !== 'string') return fallback
-  try {
-    return JSON.parse(raw) as T
-  } catch {
-    return fallback
-  }
-}
-
-export interface CostTracking {
-  id: string
-  session_id: string
-  agent_id: string
-  credits_used: number
-  direct_credits_used: number
-  created_at: string
-}
-
-// FID-2026-0803-002 DB-5: get-after-create round trips must surface an
-// explicit error instead of a confusing TypeError from a `!` assertion.
-function requireRow<T>(row: T | null, label: string): T {
-  if (row == null) {
-    throw new Error(`Failed to ${label}`)
-  }
-  return row
-}
-
-// FID-2026-0803-010 DB-C: bun:sqlite statements are reusable — prepare once
-// per SQL string and memoize instead of re-preparing on every call. Lazy (not
-// import-time) so the fail-open initDatabase and the ':memory:' test escape
-// hatch are unaffected.
-const statementCache = new Map<string, ReturnType<typeof db.prepare>>()
-
-function prepare(sql: string): ReturnType<typeof db.prepare> {
-  let stmt = statementCache.get(sql)
-  if (!stmt) {
-    stmt = db.prepare(sql)
-    statementCache.set(sql, stmt)
-  }
-  return stmt
-}
-
-// Session operations
-export function createSession(
-  chatId: string,
-  agentId: string,
-  sessionState: Record<string, unknown>,
-  selectedModel: string = '',
-): Session {
-  const id = crypto.randomUUID()
-  const stmt = prepare(`
-    INSERT INTO sessions (id, chat_id, agent_id, session_state, selected_model)
-    VALUES (?, ?, ?, ?, ?)
-  `)
-  stmt.run(id, chatId, agentId, JSON.stringify(sessionState), selectedModel)
-  return requireRow(getSession(id), `read back session ${id} after insert`)
-}
-
-export function getSession(id: string): Session | null {
-  const stmt = prepare('SELECT * FROM sessions WHERE id = ?')
-  const row = stmt.get(id) as Record<string, unknown> | null
-  if (row) {
-    return {
-      ...row,
-      session_state: parseStoredJson(row.session_state, {}),
-    } as Session
-  }
-  return null
-}
-
-export function updateSession(
-  id: string,
-  sessionState: Record<string, unknown>,
-): boolean {
-  const stmt = prepare(`
-    UPDATE sessions 
-    SET session_state = ?, updated_at = CURRENT_TIMESTAMP
-    WHERE id = ?
-  `)
-  return stmt.run(JSON.stringify(sessionState), id).changes > 0
-}
-
-// FID-2026-0803-002 DB-2: `created_at` is second-granularity, so every
-// ordering query gets a deterministic `rowid` tiebreaker — same-second rows
-// now return in insertion order instead of an unspecified order.
-export function getSessionsByChatId(chatId: string): Session[] {
-  const stmt = prepare(
-    'SELECT * FROM sessions WHERE chat_id = ? ORDER BY created_at DESC, rowid DESC',
-  )
-  const rows = stmt.all(chatId) as Record<string, unknown>[]
-  return rows.map((row) => ({
-    ...row,
-    session_state: parseStoredJson(row.session_state, {}),
-  })) as Session[]
-}
-
-// FID-2026-0803-002 DB-6: UPDATEs report whether a row was actually changed
-// so callers can detect silent no-ops on a missing id.
-export function updateSessionModel(sessionId: string, model: string): boolean {
-  const stmt = prepare(`
-    UPDATE sessions 
-    SET selected_model = ?, updated_at = CURRENT_TIMESTAMP
-    WHERE id = ?
-  `)
-  return stmt.run(model, sessionId).changes > 0
-}
-
-// FID-2026-0803-002 DB-3: single read path — `getLatestModel(chatId?)` replaces
-// the previous `getLatestModelForChat` duplicate and the ambiguous
-// `saveModel(model, chatId?)` dual-write (both removed; the CLI uses
-// `updateSessionModel` + `getLatestModel`).
-export function getLatestModel(chatId?: string): string {
-  const stmt = chatId
-    ? prepare(
-        'SELECT selected_model FROM sessions WHERE chat_id = ? ORDER BY created_at DESC, rowid DESC LIMIT 1',
-      )
-    : prepare(
-        'SELECT selected_model FROM sessions ORDER BY created_at DESC, rowid DESC LIMIT 1',
-      )
-  const row = chatId
-    ? (stmt.get(chatId) as Record<string, unknown> | null)
-    : (stmt.get() as Record<string, unknown> | null)
-  return (row?.selected_model as string) || ''
-}
-
-// Agent Template operations
-export function createAgentTemplate(
-  template: Record<string, unknown>,
-): AgentTemplate {
-  const id =
-    (typeof template.id === 'string' ? template.id : undefined) ||
-    crypto.randomUUID()
-  const stmt = prepare(`
-    INSERT INTO agent_templates (id, template)
-    VALUES (?, ?)
-  `)
-  stmt.run(id, JSON.stringify(template))
-  return requireRow(
-    getAgentTemplate(id),
-    `read back agent template ${id} after insert`,
-  )
-}
-
-export function getAgentTemplate(id: string): AgentTemplate | null {
-  const stmt = prepare('SELECT * FROM agent_templates WHERE id = ?')
-  const row = stmt.get(id) as Record<string, unknown> | null
-  if (row) {
-    return {
-      ...row,
-      template: parseStoredJson(row.template, {}),
-    } as AgentTemplate
-  }
-  return null
-}
-
-export function updateAgentTemplate(
-  id: string,
-  template: Record<string, unknown>,
-): boolean {
-  const stmt = prepare(`
-    UPDATE agent_templates 
-    SET template = ?, version = version + 1, updated_at = CURRENT_TIMESTAMP
-    WHERE id = ?
-  `)
-  return stmt.run(JSON.stringify(template), id).changes > 0
-}
-
-// FID Document operations
-export function createFidDocument(
-  sessionId: string,
-  content: string,
-  id?: string,
-): FidDocument {
-  const fidId = id || crypto.randomUUID()
-  const stmt = prepare(`
-    INSERT INTO fid_documents (id, session_id, content)
-    VALUES (?, ?, ?)
-  `)
-  stmt.run(fidId, sessionId, content)
-  return requireRow(
-    getFidDocument(fidId),
-    `read back FID document ${fidId} after insert`,
-  )
-}
-
-export function getFidDocument(id: string): FidDocument | null {
-  const stmt = prepare('SELECT * FROM fid_documents WHERE id = ?')
-  return stmt.get(id) as FidDocument | null
-}
-
-export function updateFidDocument(
-  id: string,
-  content: string,
-  status: string,
-  perfectionLoopPhase: string,
-): boolean {
-  const stmt = prepare(`
-    UPDATE fid_documents 
-    SET content = ?, status = ?, perfection_loop_phase = ?, updated_at = CURRENT_TIMESTAMP
-    WHERE id = ?
-  `)
-  return stmt.run(content, status, perfectionLoopPhase, id).changes > 0
-}
-
-// Message History operations
-// FID-006 DB1: `id` is optional and defaults to a fresh UUID; callers that
-// persist the same message repeatedly pass the message's stable id so the
-// INSERT OR IGNORE deduplicates instead of growing the table unboundedly.
-export function createMessage(
-  sessionId: string,
-  role: string,
-  content: unknown,
-  id?: string,
-): MessageHistory {
-  const messageId = id || crypto.randomUUID()
-  const stmt = prepare(`
-    INSERT OR IGNORE INTO message_history (id, session_id, role, content)
-    VALUES (?, ?, ?, ?)
-  `)
-  stmt.run(messageId, sessionId, role, JSON.stringify(content))
-  return requireRow(
-    getMessage(messageId),
-    `read back message ${messageId} after insert`,
-  )
-}
-
-export function getMessage(id: string): MessageHistory | null {
-  const stmt = prepare('SELECT * FROM message_history WHERE id = ?')
-  const row = stmt.get(id) as Record<string, unknown> | null
-  if (row) {
-    return {
-      ...row,
-      content: parseStoredJson(row.content, null),
-    } as MessageHistory
-  }
-  return null
-}
-
-export function getMessagesBySessionId(sessionId: string): MessageHistory[] {
-  const stmt = prepare(
-    'SELECT * FROM message_history WHERE session_id = ? ORDER BY created_at ASC, rowid ASC',
-  )
-  const rows = stmt.all(sessionId) as Record<string, unknown>[]
-  return rows.map((row) => ({
-    ...row,
-    content: parseStoredJson(row.content, null),
-  })) as MessageHistory[]
-}
-
-// Cost Tracking operations
-export function createCostRecord(
-  sessionId: string,
-  agentId: string,
-  creditsUsed: number,
-  directCreditsUsed: number,
-): CostTracking {
-  const id = crypto.randomUUID()
-  const stmt = prepare(`
-    INSERT INTO cost_tracking (id, session_id, agent_id, credits_used, direct_credits_used)
-    VALUES (?, ?, ?, ?, ?)
-  `)
-  stmt.run(id, sessionId, agentId, creditsUsed, directCreditsUsed)
-  return requireRow(
-    getCostRecord(id),
-    `read back cost record ${id} after insert`,
-  )
-}
-
-function getCostRecord(id: string): CostTracking | null {
-  const stmt = prepare('SELECT * FROM cost_tracking WHERE id = ?')
-  return stmt.get(id) as CostTracking | null
-}
-
-export function getCostsBySessionId(sessionId: string): CostTracking[] {
-  const stmt = prepare(
-    'SELECT * FROM cost_tracking WHERE session_id = ? ORDER BY created_at ASC, rowid ASC',
-  )
-  return stmt.all(sessionId) as CostTracking[]
-}
-
-export function getTotalCostBySessionId(sessionId: string): {
-  total_credits: number
-  total_direct_credits: number
-} {
-  const stmt = prepare(`
-    SELECT 
-      COALESCE(SUM(credits_used), 0) as total_credits,
-      COALESCE(SUM(direct_credits_used), 0) as total_direct_credits
-    FROM cost_tracking 
-    WHERE session_id = ?
-  `)
-  return stmt.get(sessionId) as {
-    total_credits: number
-    total_direct_credits: number
-  }
-}

package/packages/database/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "target": "ES2022",
-    "types": ["bun", "node"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules"]
-}

package/packages/llm-providers/README.md

@@ -1,42 +0,0 @@
-<!-- markdownlint-disable MD041 -->
-<img src="../../assets/banner.png" alt="@savant-code/llm-providers — OpenAI-compatible LLM provider shims"
-width="650" />
-
-# @savant-code/llm-providers
-
-AI SDK provider abstractions and routing logic for OpenAI-compatible LLMs (`@ai-sdk/provider` + `ai` ^5.0.52).
-
-[![License](https://img.shields.io/badge/License-Apache_2.0-%23000000?style=flat-square&logo=apache&logoColor=%2300fbff)](../../LICENSE)[![ECHO](https://img.shields.io/badge/ECHO-v0.2.0-%23000000?style=flat-square&logo=github&logoColor=%2300fbff)](../../ECHO.md)[![Status](https://img.shields.io/badge/Status-internal-%23ff9500?style=flat-square&logo=github&logoColor=%2300fbff)](../../README.md)
-
-## Purpose
-
-`@savant-code/llm-providers` is the **adapter layer** between `@savant-code/agent-runtime` and any
-OpenAI-compatible chat API (Anthropic via compatible shim, OpenAI directly, self-hosted inference). Exports the
-OpenAI-compatible surface as `./openai-compatible` plus per-provider shims. Consumed by
-`@savant-code/agent-runtime` and the CLI's selection of MAX / DEFAULT / PLAN modes.
-
-## Quick Start
-
-```bash
-# From the repo root
-bun install
-
-# Type-check
-bun --cwd packages/llm-providers typecheck
-```
-
-For full Quick Start see the [root README](../../README.md#key-technologies).
-
-## License
-
-[Apache-2.0](../../LICENSE) — see [LICENSE](../../LICENSE) for full text.
-
----
-
-<div align="center">
-
-_Part of the [savant-code/savant-code monorepo](https://github.com/savant0x/savant-code), governed by the [ECHO
-Protocol v0.2.0](../../ECHO.md)._
-
-**Savant** • 2026
-</div>

package/packages/llm-providers/package.json

@@ -1,42 +0,0 @@
-{
-  "name": "@savant-code/llm-providers",
-  "version": "0.0.1",
-  "private": true,
-  "type": "module",
-  "exports": {
-    "./openai-compatible": {
-      "bun": "./src/openai-compatible/index.ts",
-      "import": "./src/openai-compatible/index.ts",
-      "types": "./src/openai-compatible/index.ts",
-      "default": "./src/openai-compatible/index.ts"
-    },
-    "./ollama": {
-      "bun": "./src/ollama/index.ts",
-      "import": "./src/ollama/index.ts",
-      "types": "./src/ollama/index.ts",
-      "default": "./src/ollama/index.ts"
-    },
-    "./*": {
-      "bun": "./src/*.ts",
-      "import": "./src/*.ts",
-      "types": "./src/*.ts",
-      "default": "./src/*.ts"
-    }
-  },
-  "scripts": {
-    "typecheck": "tsc --noEmit -p .",
-    "test": "bun test"
-  },
-  "sideEffects": false,
-  "engines": {
-    "bun": "1.3.11"
-  },
-  "dependencies": {
-    "@ai-sdk/provider": "2.0.1",
-    "@ai-sdk/provider-utils": "^3.0.17",
-    "@savant-code/common": "workspace:*",
-    "ai": "^5.0.52",
-    "zod": "^4.2.1"
-  },
-  "devDependencies": {}
-}

package/packages/llm-providers/src/ollama/__tests__/detect.test.ts

@@ -1,59 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { detectOllama, resolveOllamaHost } from '../detect'
-
-describe('resolveOllamaHost', () => {
-  test('returns localhost by default', () => {
-    const original = process.env.OLLAMA_HOST
-    delete process.env.OLLAMA_HOST
-    expect(resolveOllamaHost()).toBe('http://localhost:11434')
-    process.env.OLLAMA_HOST = original
-  })
-
-  test('honors OLLAMA_HOST', () => {
-    const original = process.env.OLLAMA_HOST
-    process.env.OLLAMA_HOST = 'http://ollama.example.com:11434'
-    expect(resolveOllamaHost()).toBe('http://ollama.example.com:11434')
-    process.env.OLLAMA_HOST = original
-  })
-})
-
-describe('detectOllama', () => {
-  test('returns unavailable when server cannot be reached', async () => {
-    const result = await detectOllama('http://127.0.0.1:1')
-    expect(result.available).toBe(false)
-    expect(result.host).toBe('http://127.0.0.1:1')
-    expect(result.models).toEqual([])
-    expect(result.error).toBeDefined()
-  })
-
-  test('returns available when /api/tags responds', async () => {
-    // Minimal mock server
-    const server = Bun.serve({
-      port: 0,
-      async fetch(request) {
-        const url = new URL(request.url)
-        if (url.pathname === '/api/version') {
-          return new Response(JSON.stringify({ version: '0.1.0' }))
-        }
-        if (url.pathname === '/api/tags') {
-          return new Response(
-            JSON.stringify({
-              models: [{ name: 'llama3.1:latest' }, { name: 'qwen2:0.5b' }],
-            }),
-          )
-        }
-        return new Response('not found', { status: 404 })
-      },
-    })
-
-    try {
-      const result = await detectOllama(`http://localhost:${server.port}`)
-      expect(result.available).toBe(true)
-      expect(result.version).toBe('0.1.0')
-      expect(result.models).toEqual(['llama3.1:latest', 'qwen2:0.5b'])
-    } finally {
-      server.stop()
-    }
-  })
-})

package/packages/llm-providers/src/ollama/detect.ts

@@ -1,113 +0,0 @@
-/**
- * Ollama auto-detection utility.
- *
- * Probes the local Ollama daemon using its public HTTP API. The default host
- * is `http://localhost:11434`, which mirrors Ollama's own default and can be
- * overridden with the standard `OLLAMA_HOST` environment variable.
- */
-
-const DEFAULT_OLLAMA_HOST = 'http://localhost:11434'
-
-/** Public shape returned by Ollama's /api/tags endpoint. */
-interface OllamaTagsResponse {
-  models?: Array<{
-    name?: string
-    model?: string
-    size?: number
-    digest?: string
-  }>
-}
-
-/** Public shape returned by Ollama's /api/version endpoint. */
-interface OllamaVersionResponse {
-  version?: string
-}
-
-export interface OllamaDetectionResult {
-  /** Whether Ollama answered successfully on the expected endpoints. */
-  available: boolean
-  /** The base URL that was probed (useful when OLLAMA_HOST is set). */
-  host: string
-  /** Ollama server version, if available. */
-  version?: string
-  /** List of locally available model names. */
-  models: string[]
-  /** Human-readable error or hint when Ollama is not available. */
-  error?: string
-}
-
-/**
- * Resolve the Ollama host to probe.
- * Honors `OLLAMA_HOST` when set, otherwise falls back to localhost.
- */
-export function resolveOllamaHost(): string {
-  const envHost = process.env.OLLAMA_HOST?.trim()
-  if (envHost) {
-    return envHost
-  }
-  return DEFAULT_OLLAMA_HOST
-}
-
-/**
- * Detect whether Ollama is running and which models are available.
- * This function is side-effect free and does not throw; failures are returned
- * as part of the result object so callers can degrade gracefully.
- */
-export async function detectOllama(
-  host = resolveOllamaHost(),
-): Promise<OllamaDetectionResult> {
-  const baseUrl = host.endsWith('/') ? host.slice(0, -1) : host
-
-  let version: string | undefined
-  try {
-    const versionResponse = await fetch(`${baseUrl}/api/version`, {
-      signal: AbortSignal.timeout(3000),
-    })
-    if (versionResponse.ok) {
-      const versionJson =
-        (await versionResponse.json()) as OllamaVersionResponse
-      version = versionJson.version
-    }
-  } catch {
-    // Fall through to the tags probe; if both fail we report unavailability.
-  }
-
-  try {
-    const tagsResponse = await fetch(`${baseUrl}/api/tags`, {
-      signal: AbortSignal.timeout(3000),
-    })
-
-    if (!tagsResponse.ok) {
-      return {
-        available: false,
-        host: baseUrl,
-        models: [],
-        error: `Ollama responded with HTTP ${tagsResponse.status}. Make sure the server is running: ollama serve`,
-      }
-    }
-
-    const tagsJson = (await tagsResponse.json()) as OllamaTagsResponse
-    const models = (tagsJson.models ?? [])
-      .map((model) => model.name ?? model.model ?? '')
-      .filter(Boolean)
-      .sort()
-
-    return {
-      available: true,
-      host: baseUrl,
-      version,
-      models,
-      error: undefined,
-    }
-  } catch (error) {
-    return {
-      available: false,
-      host: baseUrl,
-      models: [],
-      error:
-        error instanceof Error
-          ? error.message
-          : 'Ollama is not running. Start it with: ollama serve',
-    }
-  }
-}

package/packages/llm-providers/src/ollama/index.ts

@@ -1,2 +0,0 @@
-export { detectOllama, resolveOllamaHost } from './detect'
-export type { OllamaDetectionResult } from './detect'