agentikit 0.0.9 → 0.0.12

package/src/indexer.ts

@@ -9,33 +9,27 @@ import {
   writeStashFile,
   generateMetadata,
 } from "./metadata"
-import { TfIdfAdapter, type ScoredEntry, type SerializedTfIdf } from "./similarity"
 import { walkStash } from "./walker"
-import type { EmbeddingVector } from "./embedder"
 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 IndexedEntry {
-  entry: StashEntry
-  path: string
-  dirPath: string
-  embedding?: EmbeddingVector
-}
-
-export interface SearchIndex {
-  version: number
-  builtAt: string
-  stashDir: string
-  /** All stash directories that were indexed (primary + additional) */
-  stashDirs?: string[]
-  entries: IndexedEntry[]
-  /** Serialized TF-IDF state (term frequencies, idf values) */
-  tfidf?: SerializedTfIdf
-  /** Whether embeddings are included in entries */
-  hasEmbeddings?: boolean
-}
-
 export interface IndexResponse {
   stashDir: string
   totalEntries: number
@@ -45,211 +39,240 @@ export interface IndexResponse {
   directoriesScanned: number
   directoriesSkipped: number
   /** Timing counters in milliseconds */
-  timing?: { totalMs: number; walkMs: number; embedMs: number; tfidfMs: number }
+  timing?: { totalMs: number; walkMs: number; embedMs: number; ftsMs: number }
 }
 
-// ── Constants ───────────────────────────────────────────────────────────────
+// ── Indexer ──────────────────────────────────────────────────────────────────
 
-const INDEX_VERSION = 4
+export async function agentikitIndex(options?: { stashDir?: string; full?: boolean }): Promise<IndexResponse> {
+  const stashDir = options?.stashDir || resolveStashDir()
 
-// ── Index Path ──────────────────────────────────────────────────────────────
+  // 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)
 
-export function getIndexPath(): string {
-  const cacheDir = process.env.XDG_CACHE_HOME
-    || path.join(process.env.HOME || process.env.USERPROFILE || "", ".cache")
-  return path.join(cacheDir, "agentikit", "index.json")
-}
+  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)
 
-export function loadSearchIndex(): SearchIndex | null {
-  const indexPath = getIndexPath()
-  if (!fs.existsSync(indexPath)) return null
   try {
-    const raw = JSON.parse(fs.readFileSync(indexPath, "utf8"))
-    if (raw?.version !== INDEX_VERSION) return null
-    return raw as SearchIndex
-  } catch {
-    return null
-  }
-}
+    // 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 */ }
+      }
+    }
 
-// ── Indexer ──────────────────────────────────────────────────────────────────
+    const tWalkStart = Date.now()
 
-export async function agentikitIndex(options?: { stashDir?: string; full?: boolean }): Promise<IndexResponse> {
-  const stashDir = options?.stashDir || resolveStashDir()
+    // Walk stash dirs and index entries
+    const { scannedDirs, skippedDirs, generatedCount, dirsNeedingLlm } = indexEntries(db, allStashDirs, stashDir, isIncremental, builtAtMs)
 
-  // Load config to get additional stash dirs and semantic search setting
-  const { loadConfig } = await import("./config.js")
-  const config = loadConfig(stashDir)
+    // Enhance entries with LLM if configured
+    await enhanceDirsWithLlm(db, config, dirsNeedingLlm)
 
-  const allStashDirs = [stashDir]
-  for (const d of config.additionalStashDirs) {
-    try {
-      if (fs.statSync(d).isDirectory() && !allStashDirs.includes(path.resolve(d))) {
-        allStashDirs.push(path.resolve(d))
-      }
-    } catch { /* skip nonexistent dirs */ }
-  }
+    const tWalkEnd = Date.now()
 
-  const t0 = Date.now()
-  const allEntries: IndexedEntry[] = []
-  let generatedCount = 0
-  let scannedDirs = 0
-  let skippedDirs = 0
+    // 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)
 
-  // Load previous index for incremental mode
-  const previousIndex = !options?.full ? loadSearchIndex() : null
-  const isIncremental = previousIndex !== null && previousIndex.stashDir === stashDir
-  const builtAtMs = isIncremental ? new Date(previousIndex.builtAt).getTime() : 0
-
-  // Build lookup of previous entries by dirPath
-  const previousEntriesByDir = new Map<string, IndexedEntry[]>()
-  if (isIncremental) {
-    for (const ie of previousIndex.entries) {
-      const list = previousEntriesByDir.get(ie.dirPath) || []
-      list.push(ie)
-      previousEntriesByDir.set(ie.dirPath, list)
+    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 tWalkStart = Date.now()
-
-  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 }
-
-      // Group files by their immediate parent directory
-      const dirGroups = walkStash(typeRoot, assetType)
-
-      for (const { dirPath, files } of dirGroups) {
-        // Deduplicate by dirPath across stash dirs
-        if (seenPaths.has(path.resolve(dirPath))) continue
-        seenPaths.add(path.resolve(dirPath))
-
-        // Incremental: skip directories that haven't changed
-        const prevEntries = previousEntriesByDir.get(dirPath)
-        if (isIncremental && prevEntries && !isDirStale(dirPath, files, prevEntries, builtAtMs)) {
-          allEntries.push(...prevEntries)
-          skippedDirs++
-          continue
-        }
+  const dirsNeedingLlm: Array<{ dirPath: string; files: string[]; assetType: AgentikitAssetType; currentStashDir: string }> = []
 
-        scannedDirs++
+  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
+            }
+          }
 
-        // Try loading existing .stash.json
-        let stash = loadStashFile(dirPath)
+          scannedDirs++
 
-        if (stash) {
-          const migration = migrateGeneratedSkillMetadata(stash, files, typeRoot)
-          if (migration.changed) {
-            stash = migration.stash
-            writeStashFile(dirPath, stash)
-          }
-        }
+          // Delete old entries for this dir (will be re-inserted)
+          deleteEntriesByDir(db, dirPath)
 
-        if (!stash) {
-          // Generate metadata
-          stash = generateMetadata(dirPath, assetType, files, typeRoot)
-          // Enhance with LLM if configured
-          if (config.llm && stash.entries.length > 0) {
-            stash = await enhanceStashWithLlm(config.llm, stash, dirPath, files)
-          }
-          if (stash.entries.length > 0) {
-            writeStashFile(dirPath, stash)
-            generatedCount += stash.entries.length
+          // 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) {
-          for (const entry of stash.entries) {
-            const entryPath = entry.entry
-              ? path.join(dirPath, entry.entry)
-              : files[0] || dirPath
-            allEntries.push({ entry, path: entryPath, dirPath })
+          if (!stash) {
+            // Generate metadata heuristically
+            stash = generateMetadata(dirPath, assetType, files, typeRoot)
+            if (stash.entries.length > 0) {
+              writeStashFile(dirPath, stash)
+              generatedCount += stash.entries.length
+            }
           }
-        }
-      }
-    }
-  }
 
-  const tWalkEnd = Date.now()
-
-  // Build TF-IDF index
-  const adapter = new TfIdfAdapter()
-  const scoredEntries: ScoredEntry[] = allEntries.map((ie) => ({
-    id: `${ie.entry.type}:${ie.entry.name}`,
-    text: buildSearchText(ie.entry),
-    entry: ie.entry,
-    path: ie.path,
-  }))
-  adapter.buildIndex(scoredEntries)
-  const tTfidfEnd = Date.now()
-
-  // Generate embeddings if semantic search is enabled
-  let hasEmbeddings = false
-  if (config.semanticSearch) {
-    try {
-      const { embed } = await import("./embedder.js")
-      for (const ie of allEntries) {
-        if (!ie.embedding) {
-          const text = buildSearchText(ie.entry)
-          ie.embedding = await embed(text, config.embedding)
+          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 })
+            }
+          }
         }
       }
-      hasEmbeddings = true
-    } catch {
-      // Embedding provider not available, continue without embeddings
     }
-  }
+  })
 
-  const tEmbedEnd = Date.now()
+  insertTransaction()
 
-  // Persist index
-  const indexPath = getIndexPath()
-  const indexDir = path.dirname(indexPath)
-  if (!fs.existsSync(indexDir)) {
-    fs.mkdirSync(indexDir, { recursive: true })
-  }
+  return { scannedDirs, skippedDirs, generatedCount, dirsNeedingLlm }
+}
 
-  const index: SearchIndex = {
-    version: INDEX_VERSION,
-    builtAt: new Date().toISOString(),
-    stashDir,
-    stashDirs: allStashDirs,
-    entries: allEntries,
-    tfidf: adapter.serialize(),
-    hasEmbeddings,
+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)
+    }
   }
-  fs.writeFileSync(indexPath, JSON.stringify(index) + "\n", "utf8")
+}
 
-  const tEnd = Date.now()
+async function generateEmbeddingsForDb(
+  db: import("bun:sqlite").Database,
+  config: import("./config").AgentikitConfig,
+): Promise<boolean> {
+  if (!config.semanticSearch || !isVecAvailable()) return false
 
-  return {
-    stashDir,
-    totalEntries: allEntries.length,
-    generatedMetadata: generatedCount,
-    indexPath,
-    mode: isIncremental ? "incremental" : "full",
-    directoriesScanned: scannedDirs,
-    directoriesSkipped: skippedDirs,
-    timing: {
-      totalMs: tEnd - t0,
-      walkMs: tWalkEnd - tWalkStart, // includes metadata generation (interleaved)
-      embedMs: tEmbedEnd - tTfidfEnd,
-      tfidfMs: tTfidfEnd - tWalkEnd,
-    },
+  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: IndexedEntry[],
+  previousEntries: DbIndexedEntry[],
   builtAtMs: number,
 ): boolean {
   // Check if file set changed (additions or deletions)
@@ -327,7 +350,6 @@ async function enhanceStashWithLlm(
   const enhanced: StashEntry[] = []
   for (const entry of stash.entries) {
     try {
-      // Find the file matching this entry for content context
       const entryFile = entry.entry
         ? files.find((f) => path.basename(f) === entry.entry) ?? files[0]
         : files[0]
@@ -345,7 +367,6 @@ async function enhanceStashWithLlm(
       if (improvements.tags?.length) updated.tags = improvements.tags
       enhanced.push(updated)
     } catch {
-      // LLM enhancement failed for this entry, keep original
       enhanced.push(entry)
     }
   }

package/src/init.ts

@@ -1,7 +1,7 @@
 /**
  * Agentikit initialization logic.
  *
- * Creates the stash directory structure, sets the AGENTIKIT_STASH_DIR
+ * Creates the working stash directory structure, sets the AKM_STASH_DIR
  * environment variable, and ensures ripgrep is available.
  */
 
@@ -25,7 +25,7 @@ export interface InitResponse {
   }
 }
 
-export function agentikitInit(): InitResponse {
+export async function agentikitInit(): Promise<InitResponse> {
   let stashDir: string
   if (IS_WINDOWS) {
     const userProfile = process.env.USERPROFILE?.trim()
@@ -59,7 +59,7 @@ export function agentikitInit(): InitResponse {
   let profileUpdated: string | undefined
 
   if (IS_WINDOWS) {
-    const result = spawnSync("setx", ["AGENTIKIT_STASH_DIR", stashDir], {
+    const result = spawnSync("setx", ["AKM_STASH_DIR", stashDir], {
       encoding: "utf8",
       timeout: 10_000,
     })
@@ -76,22 +76,30 @@ export function agentikitInit(): InitResponse {
       profile = path.join(homeDir, ".profile")
     }
 
-    const exportLine = `export AGENTIKIT_STASH_DIR="${stashDir}"`
+    const exportLine = `export AKM_STASH_DIR="${stashDir}"`
     const existing = fs.existsSync(profile) ? fs.readFileSync(profile, "utf8") : ""
-    if (!existing.includes("AGENTIKIT_STASH_DIR")) {
-      fs.appendFileSync(profile, `\n# Agentikit stash directory\n${exportLine}\n`)
+    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(stashDir)
+  const configPath = getConfigPath()
   if (!fs.existsSync(configPath)) {
-    saveConfig(DEFAULT_CONFIG, stashDir)
+    saveConfig(DEFAULT_CONFIG)
   }
 
-  process.env.AGENTIKIT_STASH_DIR = stashDir
+  process.env.AKM_STASH_DIR = stashDir
 
   // Ensure ripgrep is available (install to stash/bin if needed)
   let ripgrep: InitResponse["ripgrep"]

package/src/llm.ts

@@ -1,4 +1,5 @@
 import type { LlmConnectionConfig } from "./config"
+import { fetchWithTimeout } from "./common"
 import type { StashEntry } from "./metadata"
 
 // ── OpenAI-compatible chat completions ──────────────────────────────────────
@@ -21,14 +22,14 @@ async function chatCompletion(
     headers["Authorization"] = `Bearer ${config.apiKey}`
   }
 
-  const response = await fetch(config.endpoint, {
+  const response = await fetchWithTimeout(config.endpoint, {
     method: "POST",
     headers,
     body: JSON.stringify({
       model: config.model,
       messages,
-      temperature: 0.3,
-      max_tokens: 512,
+      temperature: config.temperature ?? 0.3,
+      max_tokens: config.maxTokens ?? 512,
     }),
   })
 

package/src/metadata.ts

@@ -4,6 +4,7 @@ import { type AgentikitAssetType, isAssetType } from "./common"
 import { SCRIPT_EXTENSIONS, isRelevantAssetFile, deriveCanonicalAssetName } from "./asset-spec"
 import { parseFrontmatter, toStringOrUndefined } from "./frontmatter"
 import { parseMarkdownToc, type TocHeading } from "./markdown"
+import { tryGetHandler } from "./asset-type-handler"
 
 // ── Schema ──────────────────────────────────────────────────────────────────
 
@@ -183,25 +184,10 @@ export function generateMetadata(
       }
     }
 
-    // Knowledge entries: generate TOC from headings
-    if (assetType === "knowledge") {
-      try {
-        const mdContent = fs.readFileSync(file, "utf8")
-        const toc = parseMarkdownToc(mdContent)
-        if (toc.headings.length > 0) entry.toc = toc.headings
-      } catch {
-        // Non-fatal: skip TOC if file can't be read
-      }
-    }
-
-    // Priority 3: Code comments (for script files)
-    if (SCRIPT_EXTENSIONS.has(ext) && ext !== ".md") {
-      const commentDesc = extractDescriptionFromComments(file)
-      if (commentDesc && !entry.description) {
-        entry.description = commentDesc
-        entry.source = "comments"
-        entry.confidence = 0.7
-      }
+    // Type-specific metadata extraction (e.g. TOC for knowledge, comments for tools/scripts)
+    const handler = tryGetHandler(assetType)
+    if (handler?.extractTypeMetadata) {
+      handler.extractTypeMetadata(entry, file, ext)
     }
 
     // Priority 4: Filename heuristics (fallback)
@@ -249,52 +235,6 @@ function buildAliases(name: string, tags: string[]): string[] {
   return Array.from(aliases)
 }
 
-// ── Intent Generation ────────────────────────────────────────────────────────
-
-export function generateIntents(description: string, tags: string[], name: string): string[] {
-  const intents = new Set<string>()
-
-  // Split name on separators to extract tokens and potential verb
-  const nameTokens = name
-    .replace(/[-_]+/g, " ")
-    .replace(/([a-z])([A-Z])/g, "$1 $2")
-    .toLowerCase()
-    .trim()
-    .split(/\s+/)
-    .filter((t) => t.length > 1)
-
-  // Intent from name as phrase (e.g. "summarize diff")
-  const namePhrase = nameTokens.join(" ")
-  if (namePhrase.length > 2) intents.add(namePhrase)
-
-  // Intent from description (lowercased)
-  const desc = description.toLowerCase().trim()
-  if (desc.length > 2) intents.add(desc)
-
-  // Combine first name token (potential verb) with tags
-  // e.g. name "summarize-diff", tags ["git"] → "summarize git diff"
-  if (nameTokens.length >= 1 && tags.length > 0) {
-    const verb = nameTokens[0]
-    const rest = nameTokens.slice(1).join(" ")
-    for (const tag of tags) {
-      const tagLower = tag.toLowerCase()
-      // verb + tag + rest (e.g. "summarize git diff")
-      const parts = [verb, tagLower, rest].filter((p) => p.length > 0)
-      const phrase = parts.join(" ")
-      if (phrase !== namePhrase && phrase.length > 2) intents.add(phrase)
-    }
-  }
-
-  // Join tag pairs (e.g. ["git", "diff"] → "git diff")
-  if (tags.length >= 2) {
-    const tagPhrase = tags.map((t) => t.toLowerCase()).join(" ")
-    if (tagPhrase.length > 2) intents.add(tagPhrase)
-  }
-
-  // Cap at 8 intents
-  return Array.from(intents).slice(0, 8)
-}
-
 export function extractDescriptionFromComments(filePath: string): string | null {
   let content: string
   try {