agentikit 0.0.13 → 0.0.15

package/src/indexer.ts

@@ -1,392 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import { type AgentikitAssetType, resolveStashDir } from "./common"
-import { ASSET_TYPES, TYPE_DIRS, deriveCanonicalAssetName } from "./asset-spec"
-import {
-  type StashFile,
-  type StashEntry,
-  loadStashFile,
-  writeStashFile,
-  generateMetadata,
-} from "./metadata"
-import { walkStash } from "./walker"
-import type { LlmConnectionConfig } from "./config"
-import {
-  openDatabase,
-  closeDatabase,
-  getDbPath,
-  getMeta,
-  setMeta,
-  upsertEntry,
-  deleteEntriesByDir,
-  rebuildFts,
-  upsertEmbedding,
-  getEntriesByDir,
-  getEntryCount,
-  isVecAvailable,
-  DB_VERSION,
-  type DbIndexedEntry,
-} from "./db"
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-export interface IndexResponse {
-  stashDir: string
-  totalEntries: number
-  generatedMetadata: number
-  indexPath: string
-  mode: "full" | "incremental"
-  directoriesScanned: number
-  directoriesSkipped: number
-  /** Timing counters in milliseconds */
-  timing?: { totalMs: number; walkMs: number; embedMs: number; ftsMs: number }
-}
-
-// ── Indexer ──────────────────────────────────────────────────────────────────
-
-export async function agentikitIndex(options?: { stashDir?: string; full?: boolean }): Promise<IndexResponse> {
-  const stashDir = options?.stashDir || resolveStashDir()
-
-  // Load config and resolve all stash sources
-  const { loadConfig } = await import("./config.js")
-  const config = loadConfig()
-  const { resolveAllStashDirs } = await import("./stash-source.js")
-  const allStashDirs = resolveAllStashDirs(stashDir)
-
-  const t0 = Date.now()
-
-  // Open database — pass embedding dimension from config if available
-  const dbPath = getDbPath()
-  const embeddingDim = config.embedding?.dimension
-  const db = openDatabase(dbPath, embeddingDim ? { embeddingDim } : undefined)
-
-  try {
-    // Check if we should do incremental
-    const prevStashDir = getMeta(db, "stashDir")
-    const prevBuiltAt = getMeta(db, "builtAt")
-    const isIncremental = !options?.full && prevStashDir === stashDir && !!prevBuiltAt
-    const builtAtMs = isIncremental ? new Date(prevBuiltAt!).getTime() : 0
-
-    if (options?.full || !isIncremental) {
-      // Wipe all entries for full rebuild or stashDir change
-      db.exec("DELETE FROM entries")
-      db.exec("DELETE FROM entries_fts")
-      if (isVecAvailable()) {
-        try { db.exec("DELETE FROM entries_vec") } catch { /* ignore */ }
-      }
-    }
-
-    const tWalkStart = Date.now()
-
-    // Walk stash dirs and index entries
-    const { scannedDirs, skippedDirs, generatedCount, dirsNeedingLlm } = indexEntries(db, allStashDirs, stashDir, isIncremental, builtAtMs)
-
-    // Enhance entries with LLM if configured
-    await enhanceDirsWithLlm(db, config, dirsNeedingLlm)
-
-    const tWalkEnd = Date.now()
-
-    // Rebuild FTS after all inserts
-    rebuildFts(db)
-    const tFtsEnd = Date.now()
-
-    // Generate embeddings if semantic search is enabled
-    const hasEmbeddings = await generateEmbeddingsForDb(db, config)
-
-    const tEmbedEnd = Date.now()
-
-    // Update metadata
-    setMeta(db, "version", String(DB_VERSION))
-    setMeta(db, "builtAt", new Date().toISOString())
-    setMeta(db, "stashDir", stashDir)
-    setMeta(db, "stashDirs", JSON.stringify(allStashDirs))
-    setMeta(db, "hasEmbeddings", hasEmbeddings ? "1" : "0")
-
-    const totalEntries = getEntryCount(db)
-
-    const tEnd = Date.now()
-
-    return {
-      stashDir,
-      totalEntries,
-      generatedMetadata: generatedCount,
-      indexPath: dbPath,
-      mode: isIncremental ? "incremental" : "full",
-      directoriesScanned: scannedDirs,
-      directoriesSkipped: skippedDirs,
-      timing: {
-        totalMs: tEnd - t0,
-        walkMs: tWalkEnd - tWalkStart,
-        embedMs: tEmbedEnd - tFtsEnd,
-        ftsMs: tFtsEnd - tWalkEnd,
-      },
-    }
-  } finally {
-    closeDatabase(db)
-  }
-}
-
-// ── Extracted helpers for agentikitIndex ─────────────────────────────────────
-
-function indexEntries(
-  db: import("bun:sqlite").Database,
-  allStashDirs: string[],
-  stashDir: string,
-  isIncremental: boolean,
-  builtAtMs: number,
-): { scannedDirs: number; skippedDirs: number; generatedCount: number; dirsNeedingLlm: Array<{ dirPath: string; files: string[]; assetType: AgentikitAssetType; currentStashDir: string }> } {
-  let scannedDirs = 0
-  let skippedDirs = 0
-  let generatedCount = 0
-  const seenPaths = new Set<string>()
-  const dirsNeedingLlm: Array<{ dirPath: string; files: string[]; assetType: AgentikitAssetType; currentStashDir: string }> = []
-
-  const insertTransaction = db.transaction(() => {
-    for (const currentStashDir of allStashDirs) {
-      for (const assetType of ASSET_TYPES as AgentikitAssetType[]) {
-        const typeRoot = path.join(currentStashDir, TYPE_DIRS[assetType])
-        try {
-          if (!fs.statSync(typeRoot).isDirectory()) continue
-        } catch { continue }
-
-        const dirGroups = walkStash(typeRoot, assetType)
-
-        for (const { dirPath, files } of dirGroups) {
-          if (seenPaths.has(path.resolve(dirPath))) continue
-          seenPaths.add(path.resolve(dirPath))
-
-          // Incremental: skip directories that haven't changed
-          if (isIncremental) {
-            const prevEntries = getEntriesByDir(db, dirPath)
-            if (prevEntries.length > 0 && !isDirStale(dirPath, files, prevEntries, builtAtMs)) {
-              skippedDirs++
-              continue
-            }
-          }
-
-          scannedDirs++
-
-          // Delete old entries for this dir (will be re-inserted)
-          deleteEntriesByDir(db, dirPath)
-
-          // Try loading existing .stash.json (user metadata overrides)
-          let stash = loadStashFile(dirPath)
-
-          if (stash) {
-            const migration = migrateGeneratedSkillMetadata(stash, files, typeRoot)
-            if (migration.changed) {
-              stash = migration.stash
-              writeStashFile(dirPath, stash)
-            }
-          }
-
-          if (!stash) {
-            // Generate metadata heuristically
-            stash = generateMetadata(dirPath, assetType, files, typeRoot)
-            if (stash.entries.length > 0) {
-              writeStashFile(dirPath, stash)
-              generatedCount += stash.entries.length
-            }
-          }
-
-          if (stash) {
-            for (const entry of stash.entries) {
-              const entryPath = entry.entry
-                ? path.join(dirPath, entry.entry)
-                : files[0] || dirPath
-              const entryKey = `${currentStashDir}:${entry.type}:${entry.name}`
-              const searchText = buildSearchText(entry)
-
-              upsertEntry(db, entryKey, dirPath, entryPath, currentStashDir, entry, searchText)
-            }
-
-            // Collect dirs needing LLM enhancement during the first walk
-            if (stash.entries.some((e) => e.generated)) {
-              dirsNeedingLlm.push({ dirPath, files, assetType, currentStashDir })
-            }
-          }
-        }
-      }
-    }
-  })
-
-  insertTransaction()
-
-  return { scannedDirs, skippedDirs, generatedCount, dirsNeedingLlm }
-}
-
-async function enhanceDirsWithLlm(
-  db: import("bun:sqlite").Database,
-  config: import("./config").AgentikitConfig,
-  dirsNeedingLlm: Array<{ dirPath: string; files: string[]; assetType: AgentikitAssetType; currentStashDir: string }>,
-): Promise<void> {
-  if (!config.llm || dirsNeedingLlm.length === 0) return
-
-  for (const { dirPath, files, currentStashDir } of dirsNeedingLlm) {
-    let stash = loadStashFile(dirPath)
-    if (!stash) continue
-    stash = await enhanceStashWithLlm(config.llm, stash, dirPath, files)
-    writeStashFile(dirPath, stash)
-
-    // Re-upsert enhanced entries
-    for (const entry of stash.entries) {
-      const entryPath = entry.entry ? path.join(dirPath, entry.entry) : files[0] || dirPath
-      const entryKey = `${currentStashDir}:${entry.type}:${entry.name}`
-      const searchText = buildSearchText(entry)
-      upsertEntry(db, entryKey, dirPath, entryPath, currentStashDir, entry, searchText)
-    }
-  }
-}
-
-async function generateEmbeddingsForDb(
-  db: import("bun:sqlite").Database,
-  config: import("./config").AgentikitConfig,
-): Promise<boolean> {
-  if (!config.semanticSearch || !isVecAvailable()) return false
-
-  try {
-    const { embed } = await import("./embedder.js")
-    const allEntries = getAllEntriesForEmbedding(db)
-    for (const { id, searchText } of allEntries) {
-      const embedding = await embed(searchText, config.embedding)
-      upsertEmbedding(db, id, embedding)
-    }
-    return true
-  } catch (error) {
-    console.warn("Embedding generation failed, continuing without:", error instanceof Error ? error.message : String(error))
-    return false
-  }
-}
-
-// ── Helpers ─────────────────────────────────────────────────────────────────
-
-function getAllEntriesForEmbedding(db: import("bun:sqlite").Database): Array<{ id: number; searchText: string }> {
-  return db
-    .prepare(`
-      SELECT e.id, e.search_text AS searchText FROM entries e
-      WHERE NOT EXISTS (SELECT 1 FROM entries_vec v WHERE v.id = e.id)
-    `)
-    .all() as Array<{ id: number; searchText: string }>
-}
-
-function isDirStale(
-  dirPath: string,
-  currentFiles: string[],
-  previousEntries: DbIndexedEntry[],
-  builtAtMs: number,
-): boolean {
-  // Check if file set changed (additions or deletions)
-  const prevFileNames = new Set(
-    previousEntries
-      .map((ie) => ie.entry.entry)
-      .filter((e): e is string => !!e),
-  )
-  const currFileNames = new Set(currentFiles.map((f) => path.basename(f)))
-  if (prevFileNames.size !== currFileNames.size) return true
-  for (const name of currFileNames) {
-    if (!prevFileNames.has(name)) return true
-  }
-
-  // Check modification times of current files
-  for (const file of currentFiles) {
-    try {
-      if (fs.statSync(file).mtimeMs > builtAtMs) return true
-    } catch {
-      return true
-    }
-  }
-
-  // Check .stash.json modification time
-  const stashPath = path.join(dirPath, ".stash.json")
-  try {
-    if (fs.existsSync(stashPath) && fs.statSync(stashPath).mtimeMs > builtAtMs) return true
-  } catch {
-    // ignore
-  }
-
-  return false
-}
-
-function migrateGeneratedSkillMetadata(
-  stash: StashFile,
-  files: string[],
-  typeRoot: string,
-): { stash: StashFile; changed: boolean } {
-  const fileByBaseName = new Map(files.map((filePath) => [path.basename(filePath), filePath]))
-  let changed = false
-
-  const entries = stash.entries.map((entry) => {
-    if (entry.type !== "skill" || entry.generated !== true) return entry
-
-    const hintedFilePath = entry.entry ? fileByBaseName.get(path.basename(entry.entry)) : undefined
-    const skillFilePath = hintedFilePath ?? fileByBaseName.get("SKILL.md")
-    if (!skillFilePath) return entry
-
-    const canonicalName = deriveCanonicalAssetName("skill", typeRoot, skillFilePath)
-    if (!canonicalName || canonicalName === entry.name) return entry
-
-    changed = true
-    return { ...entry, name: canonicalName }
-  })
-
-  if (!changed) {
-    return { stash, changed: false }
-  }
-
-  return {
-    stash: { entries },
-    changed: true,
-  }
-}
-
-async function enhanceStashWithLlm(
-  llmConfig: LlmConnectionConfig,
-  stash: StashFile,
-  dirPath: string,
-  files: string[],
-): Promise<StashFile> {
-  const { enhanceMetadata } = await import("./llm.js")
-
-  const enhanced: StashEntry[] = []
-  for (const entry of stash.entries) {
-    try {
-      const entryFile = entry.entry
-        ? files.find((f) => path.basename(f) === entry.entry) ?? files[0]
-        : files[0]
-      let fileContent: string | undefined
-      if (entryFile) {
-        try {
-          fileContent = fs.readFileSync(entryFile, "utf8")
-        } catch { /* ignore unreadable files */ }
-      }
-
-      const improvements = await enhanceMetadata(llmConfig, entry, fileContent)
-      const updated = { ...entry }
-      if (improvements.description) updated.description = improvements.description
-      if (improvements.intents?.length) updated.intents = improvements.intents
-      if (improvements.tags?.length) updated.tags = improvements.tags
-      enhanced.push(updated)
-    } catch {
-      enhanced.push(entry)
-    }
-  }
-  return { entries: enhanced }
-}
-
-export function buildSearchText(entry: StashEntry): string {
-  const parts: string[] = [entry.name.replace(/[-_]/g, " ")]
-  if (entry.description) parts.push(entry.description)
-  if (entry.tags) parts.push(entry.tags.join(" "))
-  if (entry.examples) parts.push(entry.examples.join(" "))
-  if (entry.aliases) parts.push(entry.aliases.join(" "))
-  if (entry.intents) parts.push(entry.intents.join(" "))
-  if (entry.intent) {
-    if (entry.intent.when) parts.push(entry.intent.when)
-    if (entry.intent.input) parts.push(entry.intent.input)
-    if (entry.intent.output) parts.push(entry.intent.output)
-  }
-  if (entry.toc) {
-    parts.push(entry.toc.map((h) => h.text).join(" "))
-  }
-  return parts.join(" ").toLowerCase()
-}

package/src/init.ts

@@ -1,114 +0,0 @@
-/**
- * Agentikit initialization logic.
- *
- * Creates the working stash directory structure, sets the AKM_STASH_DIR
- * environment variable, and ensures ripgrep is available.
- */
-
-import { spawnSync } from "node:child_process"
-import fs from "node:fs"
-import path from "node:path"
-import { IS_WINDOWS, TYPE_DIRS } from "./common"
-import { ensureRg } from "./ripgrep-install"
-import { getConfigPath, saveConfig, DEFAULT_CONFIG } from "./config"
-
-export interface InitResponse {
-  stashDir: string
-  created: boolean
-  envSet: boolean
-  profileUpdated?: string
-  configPath: string
-  ripgrep?: {
-    rgPath: string
-    installed: boolean
-    version: string
-  }
-}
-
-export async function agentikitInit(): Promise<InitResponse> {
-  let stashDir: string
-  if (IS_WINDOWS) {
-    const userProfile = process.env.USERPROFILE?.trim()
-    if (!userProfile) {
-      throw new Error("Unable to determine Documents folder. Ensure USERPROFILE is set.")
-    }
-    const docs = path.join(userProfile, "Documents")
-    stashDir = path.join(docs, "agentikit")
-  } else {
-    const home = process.env.HOME?.trim()
-    if (!home) {
-      throw new Error("Unable to determine home directory. Set HOME.")
-    }
-    stashDir = path.join(home, "agentikit")
-  }
-
-  let created = false
-  if (!fs.existsSync(stashDir)) {
-    fs.mkdirSync(stashDir, { recursive: true })
-    created = true
-  }
-
-  for (const sub of Object.values(TYPE_DIRS)) {
-    const subDir = path.join(stashDir, sub)
-    if (!fs.existsSync(subDir)) {
-      fs.mkdirSync(subDir, { recursive: true })
-    }
-  }
-
-  let envSet = false
-  let profileUpdated: string | undefined
-
-  if (IS_WINDOWS) {
-    const result = spawnSync("setx", ["AKM_STASH_DIR", stashDir], {
-      encoding: "utf8",
-      timeout: 10_000,
-    })
-    envSet = result.status === 0
-  } else {
-    const shell = process.env.SHELL || ""
-    const homeDir = process.env.HOME! // already validated non-empty above
-    let profile: string
-    if (shell.endsWith("/zsh")) {
-      profile = path.join(homeDir, ".zshrc")
-    } else if (shell.endsWith("/bash")) {
-      profile = path.join(homeDir, ".bashrc")
-    } else {
-      profile = path.join(homeDir, ".profile")
-    }
-
-    const exportLine = `export AKM_STASH_DIR="${stashDir}"`
-    const existing = fs.existsSync(profile) ? fs.readFileSync(profile, "utf8") : ""
-    if (!existing.includes("AKM_STASH_DIR")) {
-      const updated = existing + `\n# Agentikit working stash directory\n${exportLine}\n`
-      const tmpPath = profile + `.tmp.${process.pid}`
-      try {
-        fs.writeFileSync(tmpPath, updated, "utf8")
-        fs.renameSync(tmpPath, profile)
-      } catch (err) {
-        try { fs.unlinkSync(tmpPath) } catch { /* ignore */ }
-        throw err
-      }
-      envSet = true
-      profileUpdated = profile
-    }
-  }
-
-  // Create default config.json if it doesn't exist
-  const configPath = getConfigPath()
-  if (!fs.existsSync(configPath)) {
-    saveConfig(DEFAULT_CONFIG)
-  }
-
-  process.env.AKM_STASH_DIR = stashDir
-
-  // Ensure ripgrep is available (install to stash/bin if needed)
-  let ripgrep: InitResponse["ripgrep"]
-  try {
-    const rgResult = ensureRg(stashDir)
-    ripgrep = rgResult
-  } catch {
-    // Non-fatal: ripgrep is optional, search works without it
-  }
-
-  return { stashDir, created, envSet, profileUpdated, configPath, ripgrep }
-}

package/src/llm.ts

@@ -1,125 +0,0 @@
-import type { LlmConnectionConfig } from "./config"
-import { fetchWithTimeout } from "./common"
-import type { StashEntry } from "./metadata"
-
-// ── OpenAI-compatible chat completions ──────────────────────────────────────
-
-interface ChatMessage {
-  role: "system" | "user" | "assistant"
-  content: string
-}
-
-interface ChatCompletionResponse {
-  choices: Array<{ message: { content: string } }>
-}
-
-async function chatCompletion(
-  config: LlmConnectionConfig,
-  messages: ChatMessage[],
-): Promise<string> {
-  const headers: Record<string, string> = { "Content-Type": "application/json" }
-  if (config.apiKey) {
-    headers["Authorization"] = `Bearer ${config.apiKey}`
-  }
-
-  const response = await fetchWithTimeout(config.endpoint, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({
-      model: config.model,
-      messages,
-      temperature: config.temperature ?? 0.3,
-      max_tokens: config.maxTokens ?? 512,
-    }),
-  })
-
-  if (!response.ok) {
-    const body = await response.text().catch(() => "")
-    throw new Error(`LLM request failed (${response.status}): ${body}`)
-  }
-
-  const json = (await response.json()) as ChatCompletionResponse
-  return json.choices?.[0]?.message?.content?.trim() ?? ""
-}
-
-// ── Metadata Enhancement ────────────────────────────────────────────────────
-
-const SYSTEM_PROMPT = `You are a metadata generator for a developer tool registry. Given a tool/skill/command/agent entry, generate improved metadata. Respond with ONLY valid JSON, no markdown fencing.`
-
-/**
- * Use an LLM to enhance a stash entry's metadata: improve description,
- * generate intents, and suggest tags.
- */
-export async function enhanceMetadata(
-  config: LlmConnectionConfig,
-  entry: StashEntry,
-  fileContent?: string,
-): Promise<{ description?: string; intents?: string[]; tags?: string[] }> {
-  const contextParts = [
-    `Name: ${entry.name}`,
-    `Type: ${entry.type}`,
-  ]
-  if (entry.description) contextParts.push(`Current description: ${entry.description}`)
-  if (entry.tags?.length) contextParts.push(`Current tags: ${entry.tags.join(", ")}`)
-  if (fileContent) {
-    // Limit content to first 2000 chars to stay within token limits
-    const truncated = fileContent.length > 2000
-      ? fileContent.slice(0, 2000) + "\n... (truncated)"
-      : fileContent
-    contextParts.push(`File content:\n${truncated}`)
-  }
-
-  const userPrompt = `${contextParts.join("\n")}
-
-Generate improved metadata for this ${entry.type}. Return JSON with these fields:
-- "description": a clear, concise one-sentence description of what this does
-- "intents": an array of 3-6 natural language task phrases an agent might use to find this (e.g. "deploy a docker container", "run database migrations")
-- "tags": an array of 3-8 relevant keyword tags
-
-Return ONLY the JSON object, no explanation.`
-
-  const raw = await chatCompletion(config, [
-    { role: "system", content: SYSTEM_PROMPT },
-    { role: "user", content: userPrompt },
-  ])
-
-  try {
-    // Strip markdown code fences if present
-    const cleaned = raw.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "")
-    const parsed = JSON.parse(cleaned) as Record<string, unknown>
-    const result: { description?: string; intents?: string[]; tags?: string[] } = {}
-
-    if (typeof parsed.description === "string" && parsed.description) {
-      result.description = parsed.description
-    }
-    if (Array.isArray(parsed.intents)) {
-      result.intents = parsed.intents.filter(
-        (s): s is string => typeof s === "string" && s.trim().length > 0,
-      ).slice(0, 8)
-    }
-    if (Array.isArray(parsed.tags)) {
-      result.tags = parsed.tags.filter(
-        (s): s is string => typeof s === "string" && s.trim().length > 0,
-      ).slice(0, 10)
-    }
-
-    return result
-  } catch {
-    // LLM returned unparseable output, return empty
-    return {}
-  }
-}
-
-/**
- * Check if the LLM endpoint is reachable.
- */
-export async function isLlmAvailable(config: LlmConnectionConfig): Promise<boolean> {
-  try {
-    const result = await chatCompletion(config, [
-      { role: "user", content: "Respond with just the word: ok" },
-    ])
-    return result.length > 0
-  } catch {
-    return false
-  }
-}