@cue-dev/retrieval-core 0.1.3

package/test/chunking.parser-availability.poc.test.ts

@@ -0,0 +1,86 @@
+import { createRequire } from "node:module";
+import { describe, expect, it } from "vitest";
+import Parser from "tree-sitter";
+import JavaScriptV023 from "tree-sitter-javascript-v023";
+import Java from "tree-sitter-java";
+import PythonV023 from "tree-sitter-python-v023";
+import Rust from "tree-sitter-rust";
+import { Language as WebLanguage, Parser as WebParser } from "web-tree-sitter";
+import {
+  __resetChunkingParserStateForTests,
+  getChunkingParserAvailabilitySnapshot
+} from "../src/chunking.js";
+
+const require = createRequire(import.meta.url);
+
+describe("chunking parser availability PoC", () => {
+  it("captures current baseline parser availability for configured languages", () => {
+    __resetChunkingParserStateForTests();
+    const snapshot = getChunkingParserAvailabilitySnapshot({
+      enabled_languages: ["typescript", "javascript", "python", "go", "rust", "java"]
+    });
+    const byLanguage = new Map(snapshot.map((entry) => [entry.language, entry]));
+
+    expect(byLanguage.get("typescript")?.status).toBe("available");
+    expect(byLanguage.get("go")?.status).toBe("available");
+    expect(byLanguage.get("javascript")?.status).toBe("available");
+    expect(byLanguage.get("python")?.status).toBe("available");
+    expect(byLanguage.get("rust")?.status).toBe("available");
+    expect(byLanguage.get("java")?.status).toBe("available");
+  });
+
+  it("proves native availability with tree-sitter-compatible alias grammars", () => {
+    const javascriptParser = new Parser();
+    javascriptParser.setLanguage(JavaScriptV023 as unknown as Parser.Language);
+    const javascriptTree = javascriptParser.parse("function alpha(){ return 1; }\n");
+    expect(javascriptTree?.rootNode?.type).toBe("program");
+
+    const pythonParser = new Parser();
+    pythonParser.setLanguage(PythonV023 as unknown as Parser.Language);
+    const pythonTree = pythonParser.parse("def alpha():\n    return 1\n");
+    expect(pythonTree?.rootNode?.type).toBe("module");
+
+    const rustParser = new Parser();
+    rustParser.setLanguage(Rust as unknown as Parser.Language);
+    const rustTree = rustParser.parse("fn alpha() -> i32 { 1 }\n");
+    expect(rustTree?.rootNode?.type).toBe("source_file");
+
+    const javaParser = new Parser();
+    javaParser.setLanguage(Java as unknown as Parser.Language);
+    const javaTree = javaParser.parse("class Alpha { int value() { return 1; } }\n");
+    expect(javaTree?.rootNode?.type).toBe("program");
+  });
+
+  it("proves wasm availability with web-tree-sitter for javascript, python, rust, and java", async () => {
+    const runtimeWasm = require.resolve("web-tree-sitter/web-tree-sitter.wasm");
+    await WebParser.init({
+      locateFile() {
+        return runtimeWasm;
+      }
+    });
+
+    const javascriptLanguage = await WebLanguage.load(require.resolve("tree-sitter-javascript/tree-sitter-javascript.wasm"));
+    const javascriptParser = new WebParser();
+    javascriptParser.setLanguage(javascriptLanguage);
+    const javascriptTree = javascriptParser.parse("function alpha(){ return 1; }\n");
+    expect(javascriptTree?.rootNode?.type).toBe("program");
+
+    const pythonLanguage = await WebLanguage.load(require.resolve("tree-sitter-python/tree-sitter-python.wasm"));
+    const pythonParser = new WebParser();
+    pythonParser.setLanguage(pythonLanguage);
+    const pythonTree = pythonParser.parse("def alpha():\n    return 1\n");
+    expect(pythonTree?.rootNode?.type).toBe("module");
+
+    const rustLanguage = await WebLanguage.load(require.resolve("tree-sitter-rust/tree-sitter-rust.wasm"));
+    const rustParser = new WebParser();
+    rustParser.setLanguage(rustLanguage);
+    const rustTree = rustParser.parse("fn alpha() -> i32 { 1 }\n");
+    expect(rustTree?.rootNode?.type).toBe("source_file");
+
+    const javaLanguage = await WebLanguage.load(require.resolve("tree-sitter-java/tree-sitter-java.wasm"));
+    const javaParser = new WebParser();
+    javaParser.setLanguage(javaLanguage);
+    const javaTree = javaParser.parse("class Alpha { int value() { return 1; } }\n");
+    expect(javaTree?.rootNode?.type).toBe("program");
+  });
+});

package/test/claude-agent-provider.test.ts

@@ -0,0 +1,209 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const queryMock = vi.fn();
+
+vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
+  query: queryMock
+}));
+
+describe("ClaudeAgentEnhancerProvider", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+  });
+
+  it("accepts assistant text emitted after an empty result event", async () => {
+    queryMock.mockImplementation(async function* () {
+      yield { type: "result", subtype: "success", result: "" };
+      yield {
+        type: "assistant",
+        message: {
+          content: [{ type: "text", text: "{\"enhanced_prompt\":\"Use post-result assistant text\"}" }]
+        }
+      };
+    });
+
+    const { ClaudeAgentEnhancerProvider } = await import("../src/index.js");
+    const provider = new ClaudeAgentEnhancerProvider({
+      api_key: "sk-test",
+      model: "claude-sonnet-4-5-20250929",
+      permission_mode: "default"
+    });
+
+    const output = await provider.generate({
+      trace_id: "trc-provider-post-result-text",
+      tenant_id: "tenant-dev",
+      workspace_id: "ws-dev",
+      request: {
+        prompt: "Harden tenant authorization and keep behavior stable",
+        conversation_history: [],
+        project_root_path: "/workspace/dev"
+      },
+      style_requested: "standard",
+      style_resolved: "standard",
+      intent: "feature",
+      query_intent: "impl-focused",
+      language: "en",
+      context_refs: [],
+      context_snippets: [],
+      warnings: [],
+      questions: [],
+      tool_mode: "none"
+    });
+
+    expect(output.enhanced_prompt).toBe("Use post-result assistant text");
+  });
+
+  it("parses JSON text from summary messages when result text is empty", async () => {
+    queryMock.mockImplementation(async function* () {
+      yield { type: "tool_use_summary", summary: "{\"enhanced_prompt\":\"Use summary fallback\"}" };
+      yield { type: "result", subtype: "success", result: "" };
+    });
+
+    const { ClaudeAgentEnhancerProvider } = await import("../src/index.js");
+    const provider = new ClaudeAgentEnhancerProvider({
+      api_key: "sk-test",
+      model: "claude-sonnet-4-5-20250929",
+      permission_mode: "default"
+    });
+
+    const output = await provider.generate({
+      trace_id: "trc-provider-summary-fallback",
+      tenant_id: "tenant-dev",
+      workspace_id: "ws-dev",
+      request: {
+        prompt: "Harden tenant authorization and keep behavior stable",
+        conversation_history: [],
+        project_root_path: "/workspace/dev"
+      },
+      style_requested: "standard",
+      style_resolved: "standard",
+      intent: "feature",
+      query_intent: "impl-focused",
+      language: "en",
+      context_refs: [],
+      context_snippets: [],
+      warnings: [],
+      questions: [],
+      tool_mode: "none"
+    });
+
+    expect(output.enhanced_prompt).toBe("Use summary fallback");
+  });
+
+  it("returns streamed text when sdk ends with error_max_turns", async () => {
+    queryMock.mockImplementation(async function* () {
+      yield {
+        type: "stream_event",
+        event: {
+          type: "content_block_delta",
+          delta: { text: "{\"enhanced_prompt\":\"Use streamed fallback on max turns\"}" }
+        }
+      };
+      yield {
+        type: "result",
+        subtype: "error_max_turns",
+        errors: ["turn limit reached"]
+      };
+    });
+
+    const { ClaudeAgentEnhancerProvider } = await import("../src/index.js");
+    const provider = new ClaudeAgentEnhancerProvider({
+      api_key: "sk-test",
+      model: "claude-sonnet-4-5-20250929",
+      permission_mode: "default"
+    });
+
+    const output = await provider.generate({
+      trace_id: "trc-provider-max-turns-fallback",
+      tenant_id: "tenant-dev",
+      workspace_id: "ws-dev",
+      request: {
+        prompt: "Harden tenant authorization and keep behavior stable",
+        conversation_history: [],
+        project_root_path: "/workspace/dev"
+      },
+      style_requested: "standard",
+      style_resolved: "standard",
+      intent: "feature",
+      query_intent: "impl-focused",
+      language: "en",
+      context_refs: [],
+      context_snippets: [],
+      warnings: [],
+      questions: [],
+      tool_mode: "none"
+    });
+
+    expect(output.enhanced_prompt).toBe("Use streamed fallback on max turns");
+  });
+
+  it("includes extracted project conventions and output contract in payload", async () => {
+    queryMock.mockImplementation(async function* () {
+      yield { type: "result", subtype: "success", result: "{\"enhanced_prompt\":\"ok\"}" };
+    });
+
+    const { ClaudeAgentEnhancerProvider } = await import("../src/index.js");
+    const provider = new ClaudeAgentEnhancerProvider({
+      api_key: "sk-test",
+      model: "claude-sonnet-4-5-20250929",
+      permission_mode: "default"
+    });
+
+    await provider.generate({
+      trace_id: "trc-provider-conventions",
+      tenant_id: "tenant-dev",
+      workspace_id: "ws-dev",
+      request: {
+        prompt: "Harden tenant authorization and keep behavior stable",
+        conversation_history: [{ role: "user", content: "Add regression tests and keep contracts stable." }],
+        project_root_path: "/workspace/dev"
+      },
+      style_requested: "deep",
+      style_resolved: "deep",
+      intent: "feature",
+      query_intent: "impl-focused",
+      language: "en",
+      context_refs: [
+        {
+          path: "AGENTS.md",
+          start_line: 1,
+          end_line: 20,
+          reason: "exact symbol match"
+        }
+      ],
+      context_snippets: [
+        {
+          path: "AGENTS.md",
+          start_line: 1,
+          end_line: 10,
+          reason: "path and token overlap",
+          score: 0.9,
+          snippet:
+            "- Always use bun for install, scripts, and tests.\n- Maintain deterministic fallback behavior when enhancer times out."
+        }
+      ],
+      warnings: [],
+      questions: [],
+      tool_mode: "none"
+    });
+
+    const call = queryMock.mock.calls[0]?.[0] as { prompt?: string } | undefined;
+    expect(call?.prompt).toContain("Input JSON:");
+    const payloadRaw = (call?.prompt ?? "").split("Input JSON:\n")[1] ?? "";
+    const payload = JSON.parse(payloadRaw) as {
+      output_contract?: { target_style?: string };
+      project_conventions?: string[];
+      non_negotiables?: string[];
+      query_intent?: string;
+      style_requested?: string;
+      style_resolved?: string;
+    };
+    expect(payload.query_intent).toBe("impl-focused");
+    expect(payload.style_requested).toBe("deep");
+    expect(payload.style_resolved).toBe("deep");
+    expect(payload.output_contract?.target_style).toBe("deep_implementation_plan");
+    expect(payload.project_conventions?.some((entry) => /always use bun/i.test(entry))).toBe(true);
+    expect(payload.non_negotiables?.some((entry) => /regression tests/i.test(entry))).toBe(true);
+  });
+});

package/test/embedding-context-prefix.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import { InMemoryQueryCache } from "@cue-dev/data-plane";
+import { InMemoryIndexStore, RetrievalCore, type EmbeddingProvider } from "../src/index.js";
+
+class CaptureEmbeddingProvider implements EmbeddingProvider {
+  readonly calls: Array<{ texts: string[]; purpose: "index" | "query" }> = [];
+
+  async embed(input: { texts: string[]; purpose: "index" | "query" }): Promise<number[][]> {
+    this.calls.push({ texts: [...input.texts], purpose: input.purpose });
+    return input.texts.map(() => [0.1, 0.2, 0.3]);
+  }
+}
+
+describe("retrieval-core embedding context prefix", () => {
+  it("adds contextual prefix to index embedding text when enabled", async () => {
+    const store = new InMemoryIndexStore();
+    const embeddingProvider = new CaptureEmbeddingProvider();
+    const core = new RetrievalCore(store, new InMemoryQueryCache(), {
+      embeddingProvider,
+      embeddingDescriptor: {
+        provider: "test",
+        model: "capture",
+        dimensions: 3
+      },
+      chunkingConfig: {
+        embedding_context_prefix_enabled: true,
+        target_chunk_tokens: 420,
+        chunk_overlap_tokens: 90
+      }
+    });
+
+    await store.upsertWorkspace({
+      workspace_id: "ws-prefix-on",
+      tenant_id: "tenant-prefix",
+      name: "prefix-on",
+      project_root_path: "/workspace/prefix-on"
+    });
+
+    await core.indexArtifact({
+      tenant_id: "tenant-prefix",
+      workspace_id: "ws-prefix-on",
+      index_version: "idx-prefix-on-v1",
+      files: [
+        {
+          path: "src/sample.ts",
+          language: "typescript",
+          content: ["export function alpha(input: number): number {", "  return input + 1;", "}"].join("\n")
+        }
+      ]
+    });
+
+    const indexCall = embeddingProvider.calls.find((call) => call.purpose === "index");
+    expect(indexCall).toBeDefined();
+    const firstText = indexCall?.texts[0] ?? "";
+    expect(firstText.startsWith("src/sample.ts:1-3")).toBe(true);
+    expect(firstText).toContain("export function alpha");
+  });
+
+  it("keeps index embedding text unchanged when contextual prefix is disabled", async () => {
+    const store = new InMemoryIndexStore();
+    const embeddingProvider = new CaptureEmbeddingProvider();
+    const core = new RetrievalCore(store, new InMemoryQueryCache(), {
+      embeddingProvider,
+      embeddingDescriptor: {
+        provider: "test",
+        model: "capture",
+        dimensions: 3
+      },
+      chunkingConfig: {
+        embedding_context_prefix_enabled: false,
+        target_chunk_tokens: 420,
+        chunk_overlap_tokens: 90
+      }
+    });
+
+    await store.upsertWorkspace({
+      workspace_id: "ws-prefix-off",
+      tenant_id: "tenant-prefix",
+      name: "prefix-off",
+      project_root_path: "/workspace/prefix-off"
+    });
+
+    const snippet = ["export function alpha(input: number): number {", "  return input + 1;", "}"].join("\n");
+    await core.indexArtifact({
+      tenant_id: "tenant-prefix",
+      workspace_id: "ws-prefix-off",
+      index_version: "idx-prefix-off-v1",
+      files: [
+        {
+          path: "src/sample.ts",
+          language: "typescript",
+          content: snippet
+        }
+      ]
+    });
+
+    const indexCall = embeddingProvider.calls.find((call) => call.purpose === "index");
+    expect(indexCall).toBeDefined();
+    expect(indexCall?.texts[0]).toBe(snippet);
+  });
+});