fix: config overrides, resolver paths, diff preview, impact, FTS delete (#114)

* fix: config overrides, resolver paths, diff preview, impact, FTS delete

- Honor explicit empty include / excludeDirNames in config
- Reject resolver targets outside project root (prefix-safe)
- Allow empty after_pattern in diff preview (deletions)
- Pick deterministic impact call-site file_path at min depth
- deleteFileData also removes source_fts rows

* fix(test): restore config.test.ts dropped in #114

Re-add parse/load/resolve coverage from main; keep empty include/exclude tests.

Author: SutuSebastian

.changeset/fix-index-config-resolver-diff-impact.md

@@ -0,0 +1,5 @@
+---
+"@stainless-code/codemap": patch
+---
+
+Fix diff preview deletions, config empty-array overrides, resolver path containment, impact call-site selection, and FTS cleanup on file delete.

src/application/impact-engine.test.ts

@@ -70,6 +70,24 @@ describe("findImpact — symbol target via calls graph", () => {
     seedCall("src/c.ts", "c", "d");
   });
 
+  it("picks a deterministic call-site file when the same callee has multiple callers at the same depth", () => {
+    seedFile("src/z.ts");
+    seedFile("src/x.ts");
+    seedSymbol("x", "src/x.ts");
+    seedSymbol("z", "src/z.ts");
+    seedCall("src/z.ts", "z", "x");
+    seedCall("src/a.ts", "a", "x");
+    const r = findImpact(db, { target: "x", direction: "up" });
+    const callers = r.matches
+      .filter((m) => m.depth === 1)
+      .map((m) => ({ name: m.name, file_path: m.file_path }))
+      .sort((a, b) => String(a.name).localeCompare(String(b.name)));
+    expect(callers).toEqual([
+      { name: "a", file_path: "src/a.ts" },
+      { name: "z", file_path: "src/z.ts" },
+    ]);
+  });
+
   it("walks down (callees) from `a` reaches b, c, d", () => {
     const r = findImpact(db, { target: "a", direction: "down" });
     const names = r.matches.map((m) => m.name).sort();

src/application/impact-engine.ts

@@ -299,10 +299,16 @@ function walkCalls(db: CodemapDatabase, opts: WalkOpts): ImpactNode[] {
       WHERE walk.depth < ?
         AND instr(walk.path, ',' || c.${joinToCol} || ',') = 0
     )
-    SELECT node, MIN(depth) AS depth, file_path
-    FROM walk
-    WHERE depth > 0
-    GROUP BY node
+    SELECT node, depth, file_path
+    FROM (
+      SELECT node, depth, file_path,
+        ROW_NUMBER() OVER (
+          PARTITION BY node ORDER BY depth ASC, file_path ASC
+        ) AS rn
+      FROM walk
+      WHERE depth > 0
+    )
+    WHERE rn = 1
     ORDER BY depth ASC, node ASC
     LIMIT ?
   `;

src/application/output-formatters.test.ts

@@ -595,6 +595,38 @@ describe("formatDiff / formatDiffJson", () => {
     expect(readFileSync(outsidePath, "utf8")).toBe(before);
   });
 
+  it("includes deletion rows with empty after_pattern", () => {
+    writeFileSync(join(workDir, "src/a.ts"), "FIXME(team): todo\n");
+    const payload = JSON.parse(
+      formatDiffJson({
+        projectRoot: workDir,
+        rows: [
+          {
+            file_path: "src/a.ts",
+            line_start: 1,
+            before_pattern: "FIXME(team): ",
+            after_pattern: "",
+          },
+        ],
+      }),
+    );
+    expect(payload.summary.hunks).toBe(1);
+    expect(payload.files[0].hunks).toHaveLength(1);
+    const out = formatDiff({
+      projectRoot: workDir,
+      rows: [
+        {
+          file_path: "src/a.ts",
+          line_start: 1,
+          before_pattern: "FIXME(team): ",
+          after_pattern: "",
+        },
+      ],
+    });
+    expect(out).toContain("-FIXME(team): todo");
+    expect(out).toContain("+todo");
+  });
+
   it("marks missing rows when source file is gone", () => {
     const payload = JSON.parse(
       formatDiffJson({

src/application/output-formatters.ts

@@ -438,7 +438,7 @@ export function buildDiffJson(opts: DiffOpts): DiffJsonPayload {
     const filePath = readString(row, "file_path");
     const lineStart = readPositiveInt(row, "line_start");
     const before = readString(row, "before_pattern");
-    const after = readString(row, "after_pattern");
+    const after = readDiffAfterPattern(row, "after_pattern");
     if (
       filePath === undefined ||
       lineStart === undefined ||
@@ -599,6 +599,15 @@ function readString(
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 
+/** `after_pattern` may be `""` for deletions; other diff fields stay non-empty. */
+function readDiffAfterPattern(
+  row: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  const value = row[key];
+  return typeof value === "string" ? value : undefined;
+}
+
 function readPositiveInt(
   row: Record<string, unknown>,
   key: string,

src/application/path-containment.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "bun:test";
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { projectRelativePathFromResolved } from "./path-containment";
+
+describe("projectRelativePathFromResolved", () => {
+  it("rejects sibling paths that only share a string prefix with the root", () => {
+    const base = mkdtempSync(join(tmpdir(), "codemap-root-"));
+    const root = join(base, "app");
+    const outside = join(base, "application", "x.ts");
+    expect(projectRelativePathFromResolved(root, outside)).toBeNull();
+  });
+
+  it("returns a project-relative path for files inside the root", () => {
+    const root = mkdtempSync(join(tmpdir(), "codemap-in-"));
+    const inside = join(root, "src", "a.ts");
+    expect(projectRelativePathFromResolved(root, inside)).toBe("src/a.ts");
+  });
+});

src/application/path-containment.ts

@@ -33,3 +33,18 @@ export function pathEscapesProjectRoot(
   const resolvedRoot = resolve(projectRoot);
   return isAbsolute(filePath) || !isWithinProjectRoot(resolvedRoot, filePath);
 }
+
+/**
+ * Map an absolute resolved path to a project-relative path, or `null` when the
+ * target is outside the root (rejects string-prefix siblings like
+ * `/repo/app` vs `/repo/application`).
+ */
+export function projectRelativePathFromResolved(
+  projectRoot: string,
+  resolvedAbsolute: string,
+): string | null {
+  const resolvedRoot = resolve(projectRoot);
+  const abs = resolve(resolvedAbsolute);
+  if (!isWithinProjectRoot(resolvedRoot, abs)) return null;
+  return canonicalizeProjectFilePath(resolvedRoot, abs);
+}

src/config.test.ts

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 import {
+  DEFAULT_EXCLUDE_DIR_NAMES,
   DEFAULT_INCLUDE_PATTERNS,
   defineConfig,
   loadUserConfig,
@@ -105,6 +106,18 @@ describe("resolveCodemapConfig", () => {
     expect(r2.excludeDirNames.has("node_modules")).toBe(false);
   });
 
+  it("honors explicit empty include (no default patterns)", () => {
+    const r = resolveCodemapConfig(dir, { include: [] });
+    expect(r.include).toEqual([]);
+    expect(r.include).not.toEqual(DEFAULT_INCLUDE_PATTERNS);
+  });
+
+  it("honors explicit empty excludeDirNames (no default exclusions)", () => {
+    const r = resolveCodemapConfig(dir, { excludeDirNames: [] });
+    expect([...r.excludeDirNames]).toEqual([]);
+    expect(r.excludeDirNames).not.toEqual(DEFAULT_EXCLUDE_DIR_NAMES);
+  });
+
   it("defaults boundaries to []", () => {
     const r = resolveCodemapConfig(dir, undefined);
     expect(r.boundaries).toEqual([]);

src/config.ts

@@ -263,11 +263,12 @@ export function resolveCodemapConfig(
   const databasePath = parsed?.databasePath
     ? resolve(absRoot, parsed.databasePath)
     : join(stateDir, STATE_DB_NAME);
-  const include = parsed?.include?.length
-    ? [...parsed.include]
-    : [...DEFAULT_INCLUDE_PATTERNS];
+  const include =
+    parsed?.include !== undefined
+      ? [...parsed.include]
+      : [...DEFAULT_INCLUDE_PATTERNS];
   const excludeDirNames = new Set<string>(
-    parsed?.excludeDirNames?.length
+    parsed?.excludeDirNames !== undefined
       ? parsed.excludeDirNames
       : DEFAULT_EXCLUDE_DIR_NAMES,
   );

src/db.test.ts

@@ -7,6 +7,7 @@ import {
   createIndexes,
   createSchema,
   createTables,
+  deleteFileData,
   deleteQueryBaseline,
   dropAll,
   getMeta,
@@ -18,6 +19,7 @@ import {
   SCHEMA_VERSION,
   setMeta,
   upsertQueryBaseline,
+  upsertSourceFts,
 } from "./db";
 import { openCodemapDatabase } from "./sqlite-db";
 
@@ -68,6 +70,36 @@ describe("SQLite layer (in-memory)", () => {
     }
   });
 
+  it("deleteFileData removes matching source_fts rows", () => {
+    const db = openCodemapDatabase(":memory:");
+    try {
+      createSchema(db);
+      insertFile(db, {
+        path: "src/a.ts",
+        content_hash: "abc",
+        size: 1,
+        line_count: 1,
+        language: "ts",
+        last_modified: 0,
+        indexed_at: 0,
+      });
+      upsertSourceFts(db, "src/a.ts", "export const a = 1;");
+      deleteFileData(db, "src/a.ts");
+      expect(
+        db
+          .query("SELECT COUNT(*) AS n FROM files WHERE path = ?")
+          .get("src/a.ts") as { n: number },
+      ).toEqual({ n: 0 });
+      expect(
+        db
+          .query("SELECT COUNT(*) AS n FROM source_fts WHERE file_path = ?")
+          .get("src/a.ts") as { n: number },
+      ).toEqual({ n: 0 });
+    } finally {
+      closeDb(db);
+    }
+  });
+
   it("symbols.visibility round-trips with index hit on WHERE visibility = ?", () => {
     const db = openCodemapDatabase(":memory:");
     try {