@apitap/core 1.6.4 → 1.7.1

package/src/skill/search.ts

@@ -1,5 +1,5 @@
 // src/skill/search.ts
-import { listSkillFiles, readSkillFile } from './store.js';
+import { ensureIndex } from './index.js';
 
 export interface SearchResult {
   domain: string;
@@ -13,20 +13,39 @@ export interface SearchResult {
 export interface SearchResponse {
   found: boolean;
   results?: SearchResult[];
+  summary?: string;
   suggestion?: string;
 }
 
+/**
+ * Check if a search term matches a target string.
+ * Supports prefix matching: "payment" matches "payments", "pay" matches "payouts".
+ */
+function termMatches(term: string, text: string): boolean {
+  // Check if any word in the text starts with the term (prefix match)
+  // Split on word boundaries: slashes, hyphens, underscores, dots, spaces
+  const words = text.split(/[\s/\-_.]+/);
+  for (const word of words) {
+    if (word.startsWith(term)) return true;
+  }
+  // Also check plain substring for multi-word or partial path matches
+  return text.includes(term);
+}
+
 /**
  * Search skill files for endpoints matching a query.
+ * Uses the search index for sub-second results.
  * Matches against domain names, endpoint IDs, and endpoint paths.
- * Query terms are matched case-insensitively.
+ * Query terms are matched case-insensitively with prefix matching.
  */
 export async function searchSkills(
   query: string,
   skillsDir?: string,
 ): Promise<SearchResponse> {
-  const summaries = await listSkillFiles(skillsDir);
-  if (summaries.length === 0) {
+  const index = await ensureIndex(skillsDir);
+
+  const domainCount = Object.keys(index.domains).length;
+  if (domainCount === 0) {
     return {
       found: false,
       suggestion: 'No skill files found. Run `apitap capture <url>` to capture API traffic first.',
@@ -35,42 +54,42 @@ export async function searchSkills(
 
   const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
   const results: SearchResult[] = [];
+  const matchedDomains = new Set<string>();
 
-  for (const summary of summaries) {
-    const skill = await readSkillFile(summary.domain, skillsDir, { trustUnsigned: true });
-    if (!skill) continue;
-
-    const domainLower = skill.domain.toLowerCase();
+  for (const [domain, entry] of Object.entries(index.domains)) {
+    const domainLower = domain.toLowerCase();
 
-    for (const ep of skill.endpoints) {
+    for (const ep of entry.endpoints) {
       const endpointIdLower = ep.id.toLowerCase();
       const pathLower = ep.path.toLowerCase();
       const methodLower = ep.method.toLowerCase();
 
-      // Check if all query terms match against the combined searchable text
       const searchText = `${domainLower} ${endpointIdLower} ${pathLower} ${methodLower}`;
-      const allMatch = terms.every(term => searchText.includes(term));
+      const allMatch = terms.every(term => termMatches(term, searchText));
 
       if (allMatch) {
+        matchedDomains.add(domain);
         results.push({
-          domain: skill.domain,
+          domain,
           endpointId: ep.id,
           method: ep.method,
           path: ep.path,
-          tier: ep.replayability?.tier ?? 'unknown',
-          verified: ep.replayability?.verified ?? false,
+          tier: ep.tier ?? 'unknown',
+          verified: ep.verified ?? false,
         });
       }
     }
   }
 
   if (results.length === 0) {
-    const domains = summaries.map(s => s.domain).join(', ');
+    const domains = Object.keys(index.domains).join(', ');
     return {
       found: false,
+      summary: '0 endpoints across 0 domains',
       suggestion: `No matches for "${query}". Available domains: ${domains}`,
     };
   }
 
-  return { found: true, results };
+  const summary = `${results.length} endpoints across ${matchedDomains.size} domain${matchedDomains.size === 1 ? '' : 's'}`;
+  return { found: true, results, summary };
 }

package/src/skill/store.ts

@@ -4,6 +4,7 @@ import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import type { SkillFile, SkillSummary } from '../types.js';
 import { validateSkillFile } from './validate.js';
+import { updateIndex, ensureIndex } from './index.js';
 
 const DEFAULT_SKILLS_DIR = join(homedir(), '.apitap', 'skills');
 
@@ -37,6 +38,9 @@ export async function writeSkillFile(
   skill: SkillFile,
   skillsDir: string = DEFAULT_SKILLS_DIR,
 ): Promise<string> {
+  // Validate before writing — catch bad data at the source, not on read
+  validateSkillFile(skill);
+
   await mkdir(skillsDir, { recursive: true, mode: 0o700 });
   await ensureGitignore(skillsDir);
   const filePath = skillPath(skill.domain, skillsDir);
@@ -44,6 +48,26 @@ export async function writeSkillFile(
   const content = JSON.stringify(skill, null, 2) + '\n';
   await writeFile(tmpPath, content, { mode: 0o600 });
   await rename(tmpPath, filePath);
+
+  // Incrementally update the search index
+  try {
+    await updateIndex(
+      skill.domain,
+      skill.endpoints.map(ep => ({
+        id: ep.id,
+        method: ep.method,
+        path: ep.path,
+        ...(ep.replayability?.tier ? { tier: ep.replayability.tier } : {}),
+        ...(ep.replayability?.verified ? { verified: true } : {}),
+      })),
+      skill.provenance ?? 'unsigned',
+      skillsDir,
+      skill.capturedAt,
+    );
+  } catch {
+    // Index update failure should not block writes
+  }
+
   return filePath;
 }
 
@@ -111,33 +135,38 @@ export async function readSkillFile(
   }
 }
 
-export async function listSkillFiles(
+/**
+ * Fault-tolerant wrapper around readSkillFile — returns null instead of
+ * throwing on validation errors, bad signatures, etc.  ENOENT (missing
+ * file) also returns null.  Use this when iterating many files where one
+ * bad file should not abort the whole operation.
+ */
+export async function safeReadSkillFile(
+  domain: string,
   skillsDir: string = DEFAULT_SKILLS_DIR,
-): Promise<SkillSummary[]> {
-  let files: string[];
+  options?: Parameters<typeof readSkillFile>[2],
+): Promise<SkillFile | null> {
   try {
-    files = await readdir(skillsDir);
-  } catch (err: unknown) {
-    if ((err as NodeJS.ErrnoException).code === 'ENOENT') return [];
-    throw err;
+    return await readSkillFile(domain, skillsDir, options);
+  } catch {
+    return null;
   }
+}
 
+export async function listSkillFiles(
+  skillsDir: string = DEFAULT_SKILLS_DIR,
+): Promise<SkillSummary[]> {
+  const index = await ensureIndex(skillsDir);
   const summaries: SkillSummary[] = [];
-  const DOMAIN_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-  for (const file of files) {
-    if (!file.endsWith('.json')) continue;
-    const domain = file.replace(/\.json$/, '');
-    if (!DOMAIN_RE.test(domain)) continue; // skip non-conforming filenames
-    const skill = await readSkillFile(domain, skillsDir, { trustUnsigned: true });
-    if (skill) {
-      summaries.push({
-        domain: skill.domain,
-        skillFile: join(skillsDir, file),
-        endpointCount: skill.endpoints.length,
-        capturedAt: skill.capturedAt,
-        provenance: skill.provenance ?? 'unsigned',
-      });
-    }
+
+  for (const [domain, entry] of Object.entries(index.domains)) {
+    summaries.push({
+      domain,
+      skillFile: join(skillsDir, `${domain}.json`),
+      endpointCount: entry.endpointCount,
+      capturedAt: entry.capturedAt || index.builtAt,
+      provenance: entry.provenance,
+    });
   }
 
   return summaries;