@aprimediet/codewalker 1.1.0 → 1.2.0

package/src/query.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
-import { openDb, upsertSymbol, setMeta, getMeta, searchSymbols } from './db.ts';
+import { openDb, upsertSymbol, setMeta, getMeta, upsertLibSymbol, searchLibSymbols } from './db.ts';
 import { runQuery } from './query.ts';
 
 describe('query.ts', () => {
@@ -95,4 +95,75 @@ describe('query.ts', () => {
     // In a non-git dir, staleness should be null
     expect(result.staleness).toBeNull();
   });
+
+  // ── source filter ───────────────────────────────────────────
+  it('source="code" returns only code symbols (default)', () => {
+    const db = openDb(dbPath);
+    upsertSymbol(db, {
+      name: 'myFunc', kind: 'function', file_path: 'src/a.ts',
+      line_start: 1, line_end: 1, signature: '', doc: '', summary: '', card_path: '',
+    });
+    upsertLibSymbol(db, {
+      lib: 'hono', version: '4.6.3', name: 'honoFunc',
+      kind: 'function', signature: '', doc: '', summary: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'code' });
+    expect(result.rows).toHaveLength(1);
+    expect(result.rows[0]!.name).toBe('myFunc');
+    expect(result.rows[0]!.source).toBeUndefined();
+  });
+
+  it('source="libs" returns only lib symbols', () => {
+    const db = openDb(dbPath);
+    upsertSymbol(db, {
+      name: 'myFunc', kind: 'function', file_path: 'src/a.ts',
+      line_start: 1, line_end: 1, signature: '', doc: '', summary: '', card_path: '',
+    });
+    upsertLibSymbol(db, {
+      lib: 'hono', version: '4.6.3', name: 'honoFunc',
+      kind: 'function', signature: '', doc: '', summary: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'libs' });
+    expect(result.rows).toHaveLength(1);
+    expect(result.rows[0]!.name).toBe('honoFunc');
+    expect(result.rows[0]!.source).toBe('lib');
+    expect(result.rows[0]!.lib).toBe('hono');
+    expect(result.rows[0]!.version).toBe('4.6.3');
+  });
+
+  it('source="all" returns merged code and lib symbols', () => {
+    const db = openDb(dbPath);
+    upsertSymbol(db, {
+      name: 'myFunc', kind: 'function', file_path: 'src/a.ts',
+      line_start: 1, line_end: 1, signature: '', doc: '', summary: '', card_path: '',
+    });
+    upsertLibSymbol(db, {
+      lib: 'hono', version: '4.6.3', name: 'honoFunc',
+      kind: 'function', signature: '', doc: '', summary: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'all' });
+    expect(result.rows).toHaveLength(2);
+  });
+
+  it('source=all respects limit across merged set', () => {
+    const db = openDb(dbPath);
+    upsertSymbol(db, {
+      name: 'aCode', kind: 'function', file_path: 'src/a.ts',
+      line_start: 1, line_end: 1, signature: '', doc: '', summary: '', card_path: '',
+    });
+    upsertLibSymbol(db, {
+      lib: 'pkg', version: '1.0.0', name: 'bLib',
+      kind: 'function', signature: '', doc: '', summary: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'all', limit: 1 });
+    expect(result.rows).toHaveLength(1);
+  });
 });

package/src/query.ts

@@ -3,13 +3,15 @@
  */
 
 import type { QueryResult, QueryResultRow, StalenessInfo } from "./types.ts";
-import { openDb, searchSymbols, getMeta } from "./db.ts";
+import { openDb, searchSymbols, searchLibSymbols, getMeta } from "./db.ts";
 import { getHeadSha, changedFilesSince } from "./git.ts";
 
 export interface QueryParams {
   query: string;
   kind?: string;
   limit?: number;
+  /** Source scope: "code" (default, only code symbols), "libs" (only lib symbols), or "all" (both). */
+  source?: "code" | "libs" | "all";
 }
 
 /**
@@ -27,12 +29,26 @@ export function runQuery(
   const db = openDb(dbPath);
 
   try {
-    const rows = searchSymbols(
-      db,
-      params.query,
-      params.kind,
-      params.limit ?? 10,
-    );
+    const source = params.source ?? "code";
+    const limit = params.limit ?? 10;
+
+    let rows: QueryResultRow[];
+
+    if (source === "libs") {
+      rows = searchLibSymbols(db, params.query, params.kind, limit) as unknown as QueryResultRow[];
+    } else if (source === "all") {
+      // Run both code and lib searches, merge, sort by score, apply limit
+      const codeRows = searchSymbols(db, params.query, params.kind, limit);
+      const libRows = searchLibSymbols(db, params.query, params.kind, limit) as unknown as QueryResultRow[];
+
+      // Merge and sort by score ascending (lower bm25 = better match)
+      const merged: QueryResultRow[] = [...codeRows, ...libRows];
+      merged.sort((a, b) => a.score - b.score);
+      rows = merged.slice(0, limit);
+    } else {
+      // "code" — default, existing behavior
+      rows = searchSymbols(db, params.query, params.kind, limit);
+    }
 
     const staleness = detectStaleness(db, repoDir);
 

package/src/types.ts

@@ -4,6 +4,18 @@
  * These types are shared across all layers (extraction, cards, DB, query).
  */
 
+/** Library symbol kind — extends SymbolKind with reexport + namespace. */
+export type LibSymbolKind =
+  | "function"
+  | "const"
+  | "class"
+  | "interface"
+  | "type"
+  | "enum"
+  | "namespace"
+  | "reexport"
+  | "module";
+
 /** The kind of a code symbol. */
 export type SymbolKind =
   | "function"
@@ -17,6 +29,18 @@ export type SymbolKind =
   | "namespace"
   | "module";
 
+/** A single symbol extracted from a library's .d.ts file. */
+export interface LibSymbol {
+  lib: string;
+  version: string;
+  name: string;
+  kind: LibSymbolKind;
+  signature: string;
+  doc: string;
+  summary: string;
+  card_path: string;
+}
+
 /** A single symbol extracted from source code. */
 export interface Symbol {
   name: string;
@@ -51,6 +75,10 @@ export interface QueryResultRow {
   summary: string;
   score: number;
   id: number;
+  /** Origin fields — code rows omit these; lib rows set them. */
+  source?: "code" | "lib";
+  lib?: string;
+  version?: string;
 }
 
 /** The full result of a query, including staleness info. */