@aprimediet/codewalker 1.2.0 → 1.4.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, upsertLibSymbol, searchLibSymbols } from './db.ts';
+import { openDb, upsertSymbol, setMeta, getMeta, upsertLibSymbol, upsertNote, upsertFinding, searchLibSymbols } from './db.ts';
 import { runQuery } from './query.ts';
 
 describe('query.ts', () => {
@@ -166,4 +166,155 @@ describe('query.ts', () => {
     const result = runQuery(dbPath, { query: '', source: 'all', limit: 1 });
     expect(result.rows).toHaveLength(1);
   });
+
+  // ── notes source ───────────────────────────────────────────
+  it('source="notes" returns only notes', () => {
+    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: '',
+    });
+    upsertNote(db, {
+      note_kind: 'glossary', title: 'Glossary Term', body: 'A term', tags: '', related: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'notes' });
+    expect(result.rows).toHaveLength(1);
+    expect(result.rows[0]!.name).toBe('Glossary Term');
+    expect(result.rows[0]!.source).toBe('note');
+  });
+
+  it('source="all" includes notes interleaved with code and libs', () => {
+    const db = openDb(dbPath);
+    upsertSymbol(db, {
+      name: 'myFunc', kind: 'function', file_path: 'src/a.ts',
+      line_start: 1, line_end: 1, signature: '', doc: 'refresh token', summary: '', card_path: '',
+    });
+    upsertLibSymbol(db, {
+      lib: 'hono', version: '4.6.3', name: 'honoFunc',
+      kind: 'function', signature: '', doc: 'refresh token', summary: '', card_path: '',
+    });
+    upsertNote(db, {
+      note_kind: 'glossary', title: 'Refresh Token', body: 'A token used to refresh auth without re-login.', tags: 'auth', related: 'myFunc', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: 'refresh', source: 'all' });
+    expect(result.rows.length).toBeGreaterThanOrEqual(2);
+    // Should have note + lib + code (code rows have source undefined)
+    const sources = result.rows.map(r => r.source);
+    expect(sources).toContain('note');
+    expect(sources).toContain('lib');
+    expect(sources).toContain(undefined); // code rows have no source
+  });
+
+  it('source kind filter works for notes source', () => {
+    const db = openDb(dbPath);
+    upsertNote(db, {
+      note_kind: 'glossary', title: 'Term', body: 'A glossary term', tags: '', related: '', card_path: '',
+    });
+    upsertNote(db, {
+      note_kind: 'decision', title: 'Decision', body: 'A decision note', tags: '', related: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'notes', kind: 'glossary' });
+    expect(result.rows).toHaveLength(1);
+    expect(result.rows[0]!.name).toBe('Term');
+  });
+
+  it('source=all with note in query works (note matches alongside code)', () => {
+    const db = openDb(dbPath);
+    upsertSymbol(db, {
+      name: 'myFunc', kind: 'function', file_path: 'src/payments.ts',
+      line_start: 1, line_end: 10, signature: '', doc: 'processes charges', summary: '', card_path: '',
+    });
+    upsertNote(db, {
+      note_kind: 'glossary', title: 'charge', body: 'A payment processing concept.',
+      tags: 'payments', related: 'myFunc', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: 'charge', source: 'all' });
+    expect(result.rows.length).toBeGreaterThanOrEqual(1);
+    const sources = result.rows.map(r => r.source);
+    expect(sources).toContain('note');
+  });
+
+  // ── analysis source ────────────────────────────────────────
+  it('source="analysis" returns only findings', () => {
+    const db = openDb(dbPath);
+    upsertFinding(db, {
+      finding_kind: 'debt', title: 'TODO: fix', severity: 'info',
+      file_path: 'src/a.ts', line_start: 1, line_end: 1,
+      metric: 'TODO', body: 'Fix this', related: '', card_path: '',
+    });
+    upsertSymbol(db, {
+      name: 'myFunc', kind: 'function', file_path: 'src/a.ts',
+      line_start: 1, line_end: 1, signature: '', doc: '', summary: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'analysis' });
+    expect(result.rows).toHaveLength(1);
+    expect(result.rows[0]!.source).toBe('analysis');
+    expect(result.rows[0]!.finding_kind).toBe('debt');
+  });
+
+  it('source="all" includes analysis findings interleaved with code, libs, notes', () => {
+    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: '',
+    });
+    upsertFinding(db, {
+      finding_kind: 'coverage', title: 'Low coverage: a.ts', severity: 'warn',
+      file_path: 'src/a.ts', line_start: 0, line_end: 0,
+      metric: '50%', body: 'Half covered', related: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'all' });
+    expect(result.rows.length).toBeGreaterThanOrEqual(2);
+    const sources = result.rows.map(r => r.source);
+    expect(sources).toContain('analysis');
+  });
+
+  it('source="analysis" with kind filter narrows by finding_kind', () => {
+    const db = openDb(dbPath);
+    upsertFinding(db, {
+      finding_kind: 'coverage', title: 'Coverage gap', severity: 'warn',
+      file_path: 'src/a.ts', line_start: 0, line_end: 0,
+      metric: '50%', body: '', related: '', card_path: '',
+    });
+    upsertFinding(db, {
+      finding_kind: 'debt', title: 'Debt item', severity: 'high',
+      file_path: 'src/b.ts', line_start: 1, line_end: 1,
+      metric: 'TODO', body: '', related: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'analysis', kind: 'coverage' });
+    expect(result.rows).toHaveLength(1);
+    expect(result.rows[0]!.name).toBe('Coverage gap');
+  });
+
+  it('source="all" with analysis data respects limit', () => {
+    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: '',
+    });
+    upsertFinding(db, {
+      finding_kind: 'debt', title: 'Debt', severity: 'info',
+      file_path: 'src/a.ts', line_start: 1, line_end: 1,
+      metric: 'TODO', body: '', related: '', card_path: '',
+    });
+    db.close();
+
+    const result = runQuery(dbPath, { query: '', source: 'all', limit: 1 });
+    expect(result.rows).toHaveLength(1);
+  });
+
 });

package/src/query.ts

@@ -2,16 +2,16 @@
  * Query orchestration: wraps DB search with staleness detection.
  */
 
-import type { QueryResult, QueryResultRow, StalenessInfo } from "./types.ts";
-import { openDb, searchSymbols, searchLibSymbols, getMeta } from "./db.ts";
+import type { QueryResult, QueryResultRow, StalenessInfo, NoteKind, FindingKind } from "./types.ts";
+import { openDb, searchSymbols, searchLibSymbols, searchNotes, searchFindings, 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";
+  /** Source scope: "code" (default, only code symbols), "libs" (only lib symbols), "notes" (only notes), "analysis" (only findings), or "all" (all four). */
+  source?: "code" | "libs" | "notes" | "analysis" | "all";
 }
 
 /**
@@ -36,13 +36,22 @@ export function runQuery(
 
     if (source === "libs") {
       rows = searchLibSymbols(db, params.query, params.kind, limit) as unknown as QueryResultRow[];
+    } else if (source === "notes") {
+      const noteRows = searchNotes(db, params.query, params.kind as NoteKind | undefined, limit);
+      rows = noteRows as unknown as QueryResultRow[];
+    } else if (source === "analysis") {
+      const kindFilter = params.kind && ["coverage", "debt", "practice"].includes(params.kind) ? params.kind : undefined;
+      const analysisRows = searchFindings(db, params.query, kindFilter, limit) as unknown as QueryResultRow[];
+      rows = analysisRows as unknown as QueryResultRow[];
     } else if (source === "all") {
-      // Run both code and lib searches, merge, sort by score, apply limit
+      // Run code + lib + note + analysis 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[];
+      const noteRows = searchNotes(db, params.query, params.kind as NoteKind | undefined, limit * 2) as unknown as QueryResultRow[];
+      const analysisRows = searchFindings(db, params.query, undefined, limit * 2) as unknown as QueryResultRow[];
 
       // Merge and sort by score ascending (lower bm25 = better match)
-      const merged: QueryResultRow[] = [...codeRows, ...libRows];
+      const merged: QueryResultRow[] = [...codeRows, ...libRows, ...noteRows, ...analysisRows];
       merged.sort((a, b) => a.score - b.score);
       rows = merged.slice(0, limit);
     } else {

package/src/types.ts

@@ -64,6 +64,44 @@ export interface CardHead {
   summary: string;
 }
 
+/** Note kind discriminator for bridge cards. */
+export type NoteKind = "glossary" | "decision" | "convention";
+
+/** A glossary/decision note (bridge card) for conceptual knowledge. */
+export interface Note {
+  note_kind: NoteKind;
+  title: string;
+  body: string;
+  tags: string;
+  related: string;
+  card_path: string;
+}
+
+/** Analysis finding kind discriminator. */
+export type FindingKind = "coverage" | "debt" | "practice";
+
+/** A single analysis finding (coverage gap, technical debt, or best-practice finding). */
+export interface Finding {
+  finding_kind: FindingKind;
+  title: string;
+  severity?: "info" | "warn" | "high";
+  file_path?: string;
+  line_start?: number;
+  line_end?: number;
+  metric?: string;
+  body?: string;
+  related?: string;
+  card_path?: string;
+}
+
+/** Per-file coverage data from lcov or coverage-final.json. */
+export interface FileCoverage {
+  file: string;
+  lines_total: number;
+  lines_covered: number;
+  pct: number;
+}
+
 /** A single row returned from a query. */
 export interface QueryResultRow {
   name: string;
@@ -75,10 +113,16 @@ export interface QueryResultRow {
   summary: string;
   score: number;
   id: number;
-  /** Origin fields — code rows omit these; lib rows set them. */
-  source?: "code" | "lib";
+  /** Origin fields — code rows omit these; lib / note / analysis rows set them. */
+  source?: "code" | "lib" | "note" | "analysis";
+  finding_kind?: FindingKind;
+  severity?: string;
+  metric?: string;
   lib?: string;
   version?: string;
+  /** Note-specific fields — only for source === "note" rows. */
+  note_kind?: NoteKind;
+  tags?: string;
 }
 
 /** The full result of a query, including staleness info. */