agentikit 0.0.13 → 0.0.14

package/src/db.ts

@@ -1,411 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import { Database } from "bun:sqlite"
-import type { StashEntry } from "./metadata"
-import type { EmbeddingVector } from "./embedder"
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-export interface DbIndexedEntry {
-  id: number
-  entryKey: string
-  dirPath: string
-  filePath: string
-  stashDir: string
-  entry: StashEntry
-  searchText: string
-}
-
-export interface DbSearchResult {
-  id: number
-  filePath: string
-  entry: StashEntry
-  searchText: string
-  bm25Score: number
-}
-
-export interface DbVecResult {
-  id: number
-  distance: number
-}
-
-// ── Constants ───────────────────────────────────────────────────────────────
-
-export const DB_VERSION = 5
-export const EMBEDDING_DIM = 384
-
-// ── Path ────────────────────────────────────────────────────────────────────
-
-export function getDbPath(): string {
-  const cacheDir =
-    process.env.XDG_CACHE_HOME ||
-    path.join(process.env.HOME || process.env.USERPROFILE || "", ".cache")
-  return path.join(cacheDir, "agentikit", "index.db")
-}
-
-// ── Database lifecycle ──────────────────────────────────────────────────────
-
-export function openDatabase(dbPath?: string, options?: { embeddingDim?: number }): Database {
-  const resolvedPath = dbPath ?? getDbPath()
-  const dir = path.dirname(resolvedPath)
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true })
-  }
-
-  const db = new Database(resolvedPath)
-  db.exec("PRAGMA journal_mode = WAL")
-  db.exec("PRAGMA foreign_keys = ON")
-
-  // Try to load sqlite-vec extension
-  loadVecExtension(db)
-
-  ensureSchema(db, options?.embeddingDim ?? EMBEDDING_DIM)
-  return db
-}
-
-export function closeDatabase(db: Database): void {
-  db.close()
-}
-
-// ── sqlite-vec extension ────────────────────────────────────────────────────
-
-let vecAvailable = false
-
-function loadVecExtension(db: Database): void {
-  try {
-    const sqliteVec = require("sqlite-vec")
-    sqliteVec.load(db)
-    vecAvailable = true
-  } catch {
-    console.warn("sqlite-vec extension not available, embeddings will be skipped")
-    vecAvailable = false
-  }
-}
-
-export function isVecAvailable(): boolean {
-  return vecAvailable
-}
-
-// ── Schema ──────────────────────────────────────────────────────────────────
-
-function ensureSchema(db: Database, embeddingDim: number): void {
-  // Create meta table first so we can check version
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS index_meta (
-      key   TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-  `)
-
-  // Check stored version — if it differs from DB_VERSION, drop and recreate all tables
-  const storedVersion = getMeta(db, "version")
-  if (storedVersion && storedVersion !== String(DB_VERSION)) {
-    db.exec("DROP TABLE IF EXISTS entries_vec")
-    db.exec("DROP TABLE IF EXISTS entries_fts")
-    db.exec("DROP INDEX IF EXISTS idx_entries_dir")
-    db.exec("DROP INDEX IF EXISTS idx_entries_type")
-    db.exec("DROP TABLE IF EXISTS entries")
-    db.exec("DELETE FROM index_meta")
-  }
-
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS entries (
-      id          INTEGER PRIMARY KEY AUTOINCREMENT,
-      entry_key   TEXT NOT NULL UNIQUE,
-      dir_path    TEXT NOT NULL,
-      file_path   TEXT NOT NULL,
-      stash_dir   TEXT NOT NULL,
-      entry_json  TEXT NOT NULL,
-      search_text TEXT NOT NULL,
-      entry_type  TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_entries_dir ON entries(dir_path);
-    CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type);
-  `)
-
-  // FTS5 table — standalone with explicit entry_id for joining
-  const ftsExists = db
-    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_fts'")
-    .get()
-  if (!ftsExists) {
-    db.exec(`
-      CREATE VIRTUAL TABLE entries_fts USING fts5(
-        entry_id UNINDEXED,
-        search_text,
-        tokenize='porter unicode61'
-      );
-    `)
-  }
-
-  // sqlite-vec table
-  if (vecAvailable) {
-    // Check if stored embedding dimension differs from configured one
-    const storedDim = getMeta(db, "embeddingDim")
-    if (storedDim && storedDim !== String(embeddingDim)) {
-      try { db.exec("DROP TABLE IF EXISTS entries_vec") } catch { /* ignore */ }
-    }
-
-    const vecExists = db
-      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_vec'")
-      .get()
-    if (!vecExists) {
-      db.exec(`
-        CREATE VIRTUAL TABLE entries_vec USING vec0(
-          id       INTEGER PRIMARY KEY,
-          embedding FLOAT[${embeddingDim}]
-        );
-      `)
-    }
-    setMeta(db, "embeddingDim", String(embeddingDim))
-  }
-
-  // Set version if not present
-  const version = getMeta(db, "version")
-  if (!version) {
-    setMeta(db, "version", String(DB_VERSION))
-  }
-}
-
-// ── Meta helpers ────────────────────────────────────────────────────────────
-
-export function getMeta(db: Database, key: string): string | undefined {
-  const row = db.prepare("SELECT value FROM index_meta WHERE key = ?").get(key) as
-    | { value: string }
-    | undefined
-  return row?.value
-}
-
-export function setMeta(db: Database, key: string, value: string): void {
-  db.prepare("INSERT OR REPLACE INTO index_meta (key, value) VALUES (?, ?)").run(key, value)
-}
-
-// ── Entry operations ────────────────────────────────────────────────────────
-
-export function upsertEntry(
-  db: Database,
-  entryKey: string,
-  dirPath: string,
-  filePath: string,
-  stashDir: string,
-  entry: StashEntry,
-  searchText: string,
-): number {
-  const stmt = db.prepare(`
-    INSERT INTO entries (entry_key, dir_path, file_path, stash_dir, entry_json, search_text, entry_type)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(entry_key) DO UPDATE SET
-      dir_path = excluded.dir_path,
-      file_path = excluded.file_path,
-      stash_dir = excluded.stash_dir,
-      entry_json = excluded.entry_json,
-      search_text = excluded.search_text,
-      entry_type = excluded.entry_type
-  `)
-  stmt.run(entryKey, dirPath, filePath, stashDir, JSON.stringify(entry), searchText, entry.type)
-  // Fetch the row id explicitly since last_insert_rowid() is unreliable for ON CONFLICT DO UPDATE
-  const row = db.prepare("SELECT id FROM entries WHERE entry_key = ?").get(entryKey) as { id: number }
-  return row.id
-}
-
-export function deleteEntriesByDir(db: Database, dirPath: string): void {
-  if (vecAvailable) {
-    const ids = db
-      .prepare("SELECT id FROM entries WHERE dir_path = ?")
-      .all(dirPath) as Array<{ id: number }>
-    for (const { id } of ids) {
-      try {
-        db.prepare("DELETE FROM entries_vec WHERE id = ?").run(id)
-      } catch { /* ignore if vec table missing */ }
-    }
-  }
-  db.prepare("DELETE FROM entries WHERE dir_path = ?").run(dirPath)
-}
-
-export function rebuildFts(db: Database): void {
-  db.exec("DELETE FROM entries_fts")
-  db.exec("INSERT INTO entries_fts (entry_id, search_text) SELECT CAST(id AS TEXT), search_text FROM entries")
-}
-
-// ── Vector operations ───────────────────────────────────────────────────────
-
-export function upsertEmbedding(
-  db: Database,
-  entryId: number,
-  embedding: EmbeddingVector,
-): void {
-  if (!vecAvailable) return
-  const buf = float32Buffer(embedding)
-  try {
-    db.prepare("DELETE FROM entries_vec WHERE id = ?").run(entryId)
-  } catch { /* ignore */ }
-  db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)").run(entryId, buf)
-}
-
-export function searchVec(
-  db: Database,
-  queryEmbedding: EmbeddingVector,
-  k: number,
-): DbVecResult[] {
-  if (!vecAvailable) return []
-  const buf = float32Buffer(queryEmbedding)
-  try {
-    return db
-      .prepare("SELECT id, distance FROM entries_vec WHERE embedding MATCH ? AND k = ?")
-      .all(buf, k) as DbVecResult[]
-  } catch {
-    return []
-  }
-}
-
-function float32Buffer(vec: number[]): Buffer {
-  const f32 = new Float32Array(vec)
-  return Buffer.from(f32.buffer)
-}
-
-// ── FTS5 search ─────────────────────────────────────────────────────────────
-
-export function searchFts(
-  db: Database,
-  query: string,
-  limit: number,
-  entryType?: string,
-): DbSearchResult[] {
-  const ftsQuery = sanitizeFtsQuery(query)
-  if (!ftsQuery) return []
-
-  let sql: string
-  let params: unknown[]
-
-  if (entryType && entryType !== "any") {
-    sql = `
-      SELECT e.id, e.file_path AS filePath, e.entry_json, e.search_text AS searchText,
-             bm25(entries_fts) AS bm25Score
-      FROM entries_fts f
-      JOIN entries e ON e.id = CAST(f.entry_id AS INTEGER)
-      WHERE entries_fts MATCH ?
-        AND e.entry_type = ?
-      ORDER BY bm25Score
-      LIMIT ?
-    `
-    params = [ftsQuery, entryType, limit]
-  } else {
-    sql = `
-      SELECT e.id, e.file_path AS filePath, e.entry_json, e.search_text AS searchText,
-             bm25(entries_fts) AS bm25Score
-      FROM entries_fts f
-      JOIN entries e ON e.id = CAST(f.entry_id AS INTEGER)
-      WHERE entries_fts MATCH ?
-      ORDER BY bm25Score
-      LIMIT ?
-    `
-    params = [ftsQuery, limit]
-  }
-
-  try {
-    const rows = db.prepare(sql).all(...(params as import("bun:sqlite").SQLQueryBindings[])) as Array<{
-      id: number
-      filePath: string
-      entry_json: string
-      searchText: string
-      bm25Score: number
-    }>
-
-    return rows.map((row) => ({
-      id: row.id,
-      filePath: row.filePath,
-      entry: JSON.parse(row.entry_json) as StashEntry,
-      searchText: row.searchText,
-      bm25Score: row.bm25Score,
-    }))
-  } catch {
-    return []
-  }
-}
-
-function sanitizeFtsQuery(query: string): string {
-  const tokens = query
-    .replace(/[^a-zA-Z0-9\s]/g, " ")
-    .split(/\s+/)
-    .filter((t) => t.length > 1)
-  if (tokens.length === 0) return ""
-  // Use unquoted tokens so the porter stemmer can normalize word forms
-  return tokens.join(" OR ")
-}
-
-// ── All entries ─────────────────────────────────────────────────────────────
-
-export function getAllEntries(
-  db: Database,
-  entryType?: string,
-): DbIndexedEntry[] {
-  let sql: string
-  let params: unknown[]
-
-  if (entryType && entryType !== "any") {
-    sql = "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries WHERE entry_type = ?"
-    params = [entryType]
-  } else {
-    sql = "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries"
-    params = []
-  }
-
-  const rows = db.prepare(sql).all(...(params as import("bun:sqlite").SQLQueryBindings[])) as Array<{
-    id: number
-    entry_key: string
-    dir_path: string
-    file_path: string
-    stash_dir: string
-    entry_json: string
-    search_text: string
-  }>
-
-  return rows.map((row) => ({
-    id: row.id,
-    entryKey: row.entry_key,
-    dirPath: row.dir_path,
-    filePath: row.file_path,
-    stashDir: row.stash_dir,
-    entry: JSON.parse(row.entry_json) as StashEntry,
-    searchText: row.search_text,
-  }))
-}
-
-export function getEntryCount(db: Database): number {
-  const row = db.prepare("SELECT COUNT(*) AS cnt FROM entries").get() as { cnt: number }
-  return row.cnt
-}
-
-export function getEntryById(db: Database, id: number): { filePath: string; entry: StashEntry } | undefined {
-  const row = db
-    .prepare("SELECT file_path, entry_json FROM entries WHERE id = ?")
-    .get(id) as { file_path: string; entry_json: string } | undefined
-  if (!row) return undefined
-  return { filePath: row.file_path, entry: JSON.parse(row.entry_json) as StashEntry }
-}
-
-export function getEntriesByDir(db: Database, dirPath: string): DbIndexedEntry[] {
-  const rows = db
-    .prepare(
-      "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries WHERE dir_path = ?",
-    )
-    .all(dirPath) as Array<{
-    id: number
-    entry_key: string
-    dir_path: string
-    file_path: string
-    stash_dir: string
-    entry_json: string
-    search_text: string
-  }>
-
-  return rows.map((row) => ({
-    id: row.id,
-    entryKey: row.entry_key,
-    dirPath: row.dir_path,
-    filePath: row.file_path,
-    stashDir: row.stash_dir,
-    entry: JSON.parse(row.entry_json) as StashEntry,
-    searchText: row.search_text,
-  }))
-}

package/src/embedder.ts

@@ -1,128 +0,0 @@
-import type { EmbeddingConnectionConfig } from "./config"
-import { fetchWithTimeout } from "./common"
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-export type EmbeddingVector = number[]
-
-// ── Singleton local embedder ────────────────────────────────────────────────
-
-interface TransformerPipeline {
-  (text: string, options: { pooling: string; normalize: boolean }): Promise<{ data: Float32Array }>
-}
-
-let localEmbedder: TransformerPipeline | undefined
-
-async function getLocalEmbedder(): Promise<TransformerPipeline> {
-  if (!localEmbedder) {
-    let pipeline: unknown
-    try {
-      const mod = await import("@xenova/transformers")
-      pipeline = mod.pipeline as unknown
-    } catch {
-      throw new Error(
-        "Semantic search requires @xenova/transformers. Install it with: npm install @xenova/transformers",
-      )
-    }
-    const pipelineFn = pipeline as (task: string, model: string) => Promise<TransformerPipeline>
-    localEmbedder = await pipelineFn("feature-extraction", "Xenova/all-MiniLM-L6-v2")
-  }
-  return localEmbedder!
-}
-
-async function embedLocal(text: string): Promise<EmbeddingVector> {
-  const model = await getLocalEmbedder()
-  const result = await model(text, { pooling: "mean", normalize: true })
-  return Array.from(result.data) as number[]
-}
-
-// ── OpenAI-compatible remote embedder ───────────────────────────────────────
-
-async function embedRemote(
-  text: string,
-  config: EmbeddingConnectionConfig,
-): Promise<EmbeddingVector> {
-  const headers: Record<string, string> = { "Content-Type": "application/json" }
-  if (config.apiKey) {
-    headers["Authorization"] = `Bearer ${config.apiKey}`
-  }
-
-  const body: { input: string; model: string; dimensions?: number } = {
-    input: text,
-    model: config.model,
-  }
-  if (config.dimension) {
-    body.dimensions = config.dimension
-  }
-
-  const response = await fetchWithTimeout(config.endpoint, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-  })
-
-  if (!response.ok) {
-    const body = await response.text().catch(() => "")
-    throw new Error(`Embedding request failed (${response.status}): ${body}`)
-  }
-
-  const json = (await response.json()) as {
-    data: Array<{ embedding: number[] }>
-  }
-
-  if (!json.data?.[0]?.embedding) {
-    throw new Error("Unexpected embedding response format: missing data[0].embedding")
-  }
-
-  return json.data[0].embedding
-}
-
-// ── Public API ──────────────────────────────────────────────────────────────
-
-/**
- * Generate an embedding for the given text.
- * If embeddingConfig is provided, uses the configured OpenAI-compatible endpoint.
- * Otherwise falls back to local @xenova/transformers.
- */
-export async function embed(
-  text: string,
-  embeddingConfig?: EmbeddingConnectionConfig,
-): Promise<EmbeddingVector> {
-  if (embeddingConfig) {
-    return embedRemote(text, embeddingConfig)
-  }
-  return embedLocal(text)
-}
-
-// ── Similarity ──────────────────────────────────────────────────────────────
-
-export function cosineSimilarity(a: EmbeddingVector, b: EmbeddingVector): number {
-  const len = Math.min(a.length, b.length)
-  if (len === 0) return 0
-  let dot = 0
-  for (let i = 0; i < len; i++) {
-    dot += a[i] * b[i]
-  }
-  return dot
-}
-
-// ── Availability check ──────────────────────────────────────────────────────
-
-export async function isEmbeddingAvailable(
-  embeddingConfig?: EmbeddingConnectionConfig,
-): Promise<boolean> {
-  if (embeddingConfig) {
-    try {
-      await embedRemote("test", embeddingConfig)
-      return true
-    } catch {
-      return false
-    }
-  }
-  try {
-    await getLocalEmbedder()
-    return true
-  } catch {
-    return false
-  }
-}

package/src/frontmatter.ts

@@ -1,95 +0,0 @@
-/**
- * Shared frontmatter parsing utilities.
- *
- * Provides a single, canonical YAML-subset frontmatter parser used by both
- * the stash open logic and the metadata generator.
- */
-
-/**
- * Parse YAML-subset frontmatter from a Markdown (or similar) string.
- *
- * Returns the parsed key-value data and the remaining body content.
- */
-export function parseFrontmatter(raw: string): {
-  data: Record<string, unknown>
-  content: string
-  frontmatter: string | null
-  bodyStartLine: number
-} {
-  const parsedBlock = parseFrontmatterBlock(raw)
-  if (!parsedBlock) {
-    return { data: {}, content: raw, frontmatter: null, bodyStartLine: 1 }
-  }
-
-  const data: Record<string, unknown> = {}
-  let currentKey: string | null = null
-  let nested: Record<string, unknown> | null = null
-
-  for (const line of parsedBlock.frontmatter.split(/\r?\n/)) {
-    const indented = line.match(/^  (\w[\w-]*):\s*(.+)$/)
-    if (indented && currentKey && nested) {
-      nested[indented[1]] = parseYamlScalar(indented[2].trim())
-      continue
-    }
-
-    const top = line.match(/^(\w[\w-]*):\s*(.*)$/)
-    if (!top) {
-      continue
-    }
-
-    currentKey = top[1]
-    const value = top[2].trim()
-    if (value === "") {
-      nested = {}
-      data[currentKey] = nested
-    } else {
-      nested = null
-      data[currentKey] = parseYamlScalar(value)
-    }
-  }
-  return {
-    data,
-    content: parsedBlock.content,
-    frontmatter: parsedBlock.frontmatter,
-    bodyStartLine: parsedBlock.bodyStartLine,
-  }
-}
-
-export function parseFrontmatterBlock(
-  raw: string,
-): { frontmatter: string; content: string; bodyStartLine: number } | null {
-  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/)
-  if (!match) return null
-  return {
-    frontmatter: match[1],
-    content: match[2],
-    bodyStartLine: countLines(raw.slice(0, match[0].length - match[2].length)) + 1,
-  }
-}
-
-function countLines(text: string): number {
-  if (text.length === 0) return 0
-  return text.split(/\r?\n/).length - 1
-}
-
-/**
- * Parse a simple YAML scalar value (string, boolean, or number).
- */
-export function parseYamlScalar(value: string): unknown {
-  if (value === "") return ""
-  if (value === "true") return true
-  if (value === "false") return false
-  const asNumber = Number(value)
-  if (!Number.isNaN(asNumber)) return asNumber
-  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-    return value.slice(1, -1)
-  }
-  return value
-}
-
-/**
- * Coerce an unknown value to a trimmed string, or return undefined if empty/non-string.
- */
-export function toStringOrUndefined(value: unknown): string | undefined {
-  return typeof value === "string" && value.trim() ? value : undefined
-}

package/src/github.ts

@@ -1,21 +0,0 @@
-export const GITHUB_API_BASE = "https://api.github.com"
-
-export function githubHeaders(): HeadersInit {
-  const token = process.env.GITHUB_TOKEN?.trim()
-  const headers: Record<string, string> = {
-    Accept: "application/vnd.github+json",
-    "User-Agent": "agentikit-registry",
-  }
-  if (token) headers.Authorization = `Bearer ${token}`
-  return headers
-}
-
-export function asRecord(value: unknown): Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-    ? value as Record<string, unknown>
-    : {}
-}
-
-export function asString(value: unknown): string | undefined {
-  return typeof value === "string" && value ? value : undefined
-}

package/src/handlers/agent-handler.ts

@@ -1,32 +0,0 @@
-import { parseFrontmatter, toStringOrUndefined } from "../frontmatter"
-import { isMarkdownFile, markdownCanonicalName, markdownAssetPath } from "./markdown-helpers"
-import type { AssetTypeHandler, ShowInput } from "../asset-type-handler"
-import type { ShowResponse } from "../stash-types"
-
-export const agentHandler: AssetTypeHandler = {
-  typeName: "agent",
-  stashDir: "agents",
-
-  isRelevantFile: isMarkdownFile,
-  toCanonicalName: markdownCanonicalName,
-  toAssetPath: markdownAssetPath,
-
-  buildShowResponse(input: ShowInput): ShowResponse {
-    const parsedMd = parseFrontmatter(input.content)
-    return {
-      type: "agent",
-      name: input.name,
-      path: input.path,
-      description: toStringOrUndefined(parsedMd.data.description),
-      prompt: "Dispatching prompt must include the agent's full prompt content verbatim; summaries are non-compliant. \n\n"
-        + parsedMd.content,
-      toolPolicy: parsedMd.data.tools,
-      modelHint: parsedMd.data.model,
-    }
-  },
-
-  defaultUsageGuide: [
-    "Read the .md file and dispatch an agent using the content of the file. Use modelHint/toolPolicy when present to run the agent with compatible settings.",
-    "Use with `akm show <openRef>` to get the full prompt payload.",
-  ],
-}