aiwcli 0.15.5 → 0.17.0

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/__tests__/hyde.test.ts

@@ -0,0 +1,365 @@
+import { expect } from "chai";
+
+// Inline versions of HyDE functions for testing (avoids module loading issues with types.ts)
+
+const HYDE_SYSTEM_PROMPT = `You are a knowledge base assistant. Given a user query about past coding sessions, generate a hypothetical answer that MIGHT exist in session transcripts.
+
+Rules:
+- Write 2-3 sentences maximum (under 200 tokens)
+- Use specific technical language: file names, function names, error messages, tool names
+- Describe actions taken, decisions made, or problems solved
+- Do NOT say "I don't know" or ask clarifying questions
+- Be concrete and specific, even if speculative
+
+Example:
+
+Query: "How did we fix the authentication redirect loop?"
+
+Hypothetical Answer: "The redirect loop was caused by middleware checking session.user before the session was populated. We moved the auth check to a route-level guard in src/middleware/auth.ts and updated the session initialization order in app.ts to populate user data before routing."`;
+
+function averageEmbeddings(embeddings: Float32Array[]): Float32Array {
+  if (embeddings.length === 0) {
+    throw new Error("No embeddings to average");
+  }
+
+  const dim = embeddings[0].length;
+  const avg = new Float32Array(dim);
+
+  for (const emb of embeddings) {
+    for (let i = 0; i < dim; i++) {
+      avg[i] += emb[i];
+    }
+  }
+
+  const n = embeddings.length;
+  for (let i = 0; i < dim; i++) {
+    avg[i] /= n;
+  }
+
+  return avg;
+}
+
+async function hydeQueryEmbedding(
+  query: string,
+  config: {
+    numResponses: number;
+    maxTokens: number;
+    timeout: number;
+    fallbackToQuery: boolean;
+  },
+  generateTextFn: any,
+  embedFn: any,
+  embedOneFn: any,
+): Promise<Float32Array> {
+  const promises = Array.from({ length: config.numResponses }, (_, i) =>
+    generateTextFn(query, {
+      systemPrompt: HYDE_SYSTEM_PROMPT,
+      maxTokens: config.maxTokens,
+      timeout: config.timeout,
+      temperature: 0.7,
+    }),
+  );
+
+  const results = await Promise.all(promises);
+  const responses = results
+    .filter((r: any) => r.success && r.text.trim().length > 20)
+    .map((r: any) => r.text.trim());
+
+  if (responses.length < 3) {
+    if (config.fallbackToQuery) {
+      return embedOneFn(query);
+    }
+    throw new Error("HyDE generation failed: insufficient responses");
+  }
+
+  const embeddings = await embedFn(responses);
+  const avg = averageEmbeddings(embeddings);
+
+  return avg;
+}
+
+describe("hyde (HyDE logic)", () => {
+  describe("averageEmbeddings", () => {
+    it("averages embeddings correctly", () => {
+      const emb1 = new Float32Array([1.0, 2.0, 3.0]);
+      const emb2 = new Float32Array([2.0, 4.0, 6.0]);
+      const emb3 = new Float32Array([3.0, 6.0, 9.0]);
+
+      const result = averageEmbeddings([emb1, emb2, emb3]);
+
+      expect(Array.from(result)).to.deep.equal([2.0, 4.0, 6.0]);
+    });
+
+    it("preserves dimensionality", () => {
+      const emb1 = new Float32Array([1.0, 2.0, 3.0, 4.0, 5.0]);
+      const emb2 = new Float32Array([5.0, 4.0, 3.0, 2.0, 1.0]);
+
+      const result = averageEmbeddings([emb1, emb2]);
+
+      expect(result.length).to.equal(5);
+      expect(Array.from(result)).to.deep.equal([3.0, 3.0, 3.0, 3.0, 3.0]);
+    });
+
+    it("handles single embedding", () => {
+      const emb = new Float32Array([10.0, 20.0, 30.0]);
+
+      const result = averageEmbeddings([emb]);
+
+      expect(Array.from(result)).to.deep.equal([10.0, 20.0, 30.0]);
+    });
+
+    it("throws error for empty array", () => {
+      expect(() => averageEmbeddings([])).to.throw("No embeddings to average");
+    });
+  });
+
+  describe("hydeQueryEmbedding", () => {
+    it("generates hypothetical responses and returns averaged embedding", async () => {
+      const mockGenerateText = async () => ({
+        success: true,
+        text: "This is a hypothetical response about fixing authentication bugs in the login module.",
+        latency_ms: 500,
+      });
+
+      const mockEmbed = async (texts: string[]) => {
+        return texts.map(() => new Float32Array([1.0, 2.0, 3.0, 4.0]));
+      };
+
+      const mockEmbedOne = async () => new Float32Array([0, 0, 0, 0]);
+
+      const result = await hydeQueryEmbedding(
+        "How did we fix auth bugs?",
+        {
+          numResponses: 5,
+          maxTokens: 200,
+          timeout: 10000,
+          fallbackToQuery: true,
+        },
+        mockGenerateText,
+        mockEmbed,
+        mockEmbedOne,
+      );
+
+      expect(result).to.be.instanceOf(Float32Array);
+      expect(result.length).to.equal(4);
+      expect(Array.from(result)).to.deep.equal([1.0, 2.0, 3.0, 4.0]);
+    });
+
+    it("averages different embeddings correctly", async () => {
+      const mockGenerateText = async () => ({
+        success: true,
+        text: "Hypothetical response text that is long enough to pass the filter.",
+        latency_ms: 500,
+      });
+
+      let callCount = 0;
+      const mockEmbed = async (texts: string[]) => {
+        return texts.map(() => {
+          callCount++;
+          if (callCount === 1) return new Float32Array([1.0, 2.0, 3.0]);
+          if (callCount === 2) return new Float32Array([2.0, 4.0, 6.0]);
+          return new Float32Array([3.0, 6.0, 9.0]);
+        });
+      };
+
+      const mockEmbedOne = async () => new Float32Array([0, 0, 0]);
+
+      const result = await hydeQueryEmbedding(
+        "test query",
+        {
+          numResponses: 3,
+          maxTokens: 200,
+          timeout: 10000,
+          fallbackToQuery: true,
+        },
+        mockGenerateText,
+        mockEmbed,
+        mockEmbedOne,
+      );
+
+      expect(Array.from(result)).to.deep.equal([2.0, 4.0, 6.0]);
+    });
+
+    it("falls back to direct query embedding when < 3 responses", async () => {
+      let callCount = 0;
+      const mockGenerateText = async () => {
+        callCount++;
+        if (callCount <= 2) {
+          return {
+            success: true,
+            text: "This is a valid response with sufficient length to pass filter.",
+            latency_ms: 500,
+          };
+        }
+        return {
+          success: false,
+          text: "",
+          error: "Generation failed",
+          latency_ms: 100,
+        };
+      };
+
+      const mockEmbed = async () => [];
+      const mockEmbedOne = async (query: string) => {
+        return new Float32Array([10.0, 20.0, 30.0]);
+      };
+
+      const result = await hydeQueryEmbedding(
+        "test query",
+        {
+          numResponses: 5,
+          maxTokens: 200,
+          timeout: 10000,
+          fallbackToQuery: true,
+        },
+        mockGenerateText,
+        mockEmbed,
+        mockEmbedOne,
+      );
+
+      expect(Array.from(result)).to.deep.equal([10.0, 20.0, 30.0]);
+    });
+
+    it("throws error when < 3 responses and fallbackToQuery is false", async () => {
+      const mockGenerateText = async () => ({
+        success: false,
+        text: "",
+        error: "All generations failed",
+        latency_ms: 100,
+      });
+
+      const mockEmbed = async () => [];
+      const mockEmbedOne = async () => new Float32Array([0]);
+
+      try {
+        await hydeQueryEmbedding(
+          "test query",
+          {
+            numResponses: 5,
+            maxTokens: 200,
+            timeout: 10000,
+            fallbackToQuery: false,
+          },
+          mockGenerateText,
+          mockEmbed,
+          mockEmbedOne,
+        );
+        expect.fail("Should have thrown error");
+      } catch (e: any) {
+        expect(e.message).to.include("HyDE generation failed");
+        expect(e.message).to.include("insufficient responses");
+      }
+    });
+
+    it("filters out responses shorter than 20 characters", async () => {
+      let callCount = 0;
+      const mockGenerateText = async () => {
+        callCount++;
+        if (callCount <= 2) {
+          return {
+            success: true,
+            text: "Too short",
+            latency_ms: 500,
+          };
+        }
+        return {
+          success: true,
+          text: "This is a sufficiently long response that passes the filter.",
+          latency_ms: 500,
+        };
+      };
+
+      const mockEmbed = async (texts: string[]) => {
+        return texts.map(() => new Float32Array([5.0, 10.0]));
+      };
+
+      const mockEmbedOne = async () => new Float32Array([0, 0]);
+
+      const result = await hydeQueryEmbedding(
+        "test",
+        {
+          numResponses: 5,
+          maxTokens: 200,
+          timeout: 10000,
+          fallbackToQuery: true,
+        },
+        mockGenerateText,
+        mockEmbed,
+        mockEmbedOne,
+      );
+
+      // Only 3 long responses should pass, meeting threshold
+      expect(Array.from(result)).to.deep.equal([5.0, 10.0]);
+    });
+
+    it("handles all failed generations by falling back", async () => {
+      const mockGenerateText = async () => ({
+        success: false,
+        text: "",
+        error: "Ollama connection refused",
+        latency_ms: 50,
+      });
+
+      const mockEmbed = async () => [];
+      const mockEmbedOne = async (query: string) => {
+        return new Float32Array([100.0, 200.0]);
+      };
+
+      const result = await hydeQueryEmbedding(
+        "test query",
+        {
+          numResponses: 5,
+          maxTokens: 200,
+          timeout: 10000,
+          fallbackToQuery: true,
+        },
+        mockGenerateText,
+        mockEmbed,
+        mockEmbedOne,
+      );
+
+      expect(Array.from(result)).to.deep.equal([100.0, 200.0]);
+    });
+
+    it("works with exactly 3 successful responses", async () => {
+      let callCount = 0;
+      const mockGenerateText = async () => {
+        callCount++;
+        if (callCount <= 3) {
+          return {
+            success: true,
+            text: "Valid hypothetical response with enough characters to pass.",
+            latency_ms: 500,
+          };
+        }
+        return {
+          success: false,
+          text: "",
+          error: "Failed",
+          latency_ms: 100,
+        };
+      };
+
+      const mockEmbed = async (texts: string[]) => {
+        return texts.map(() => new Float32Array([5.0, 10.0]));
+      };
+
+      const mockEmbedOne = async () => new Float32Array([0, 0]);
+
+      const result = await hydeQueryEmbedding(
+        "test",
+        {
+          numResponses: 5,
+          maxTokens: 200,
+          timeout: 10000,
+          fallbackToQuery: true,
+        },
+        mockGenerateText,
+        mockEmbed,
+        mockEmbedOne,
+      );
+
+      expect(Array.from(result)).to.deep.equal([5.0, 10.0]);
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/__tests__/ollama-client.test.ts

@@ -0,0 +1,223 @@
+import { expect } from "chai";
+
+// Simplified test approach: test the logic without importing the full module
+// to avoid module-level config loading issues in types.ts
+
+let originalFetch: typeof global.fetch;
+
+// Inline version of generateText for testing (avoids module loading issues)
+async function generateText(
+  prompt: string,
+  options?: {
+    systemPrompt?: string;
+    temperature?: number;
+    maxTokens?: number;
+    timeout?: number;
+    model?: string;
+  },
+): Promise<{ success: boolean; text: string; error?: string; latency_ms: number }> {
+  const startTime = Date.now();
+  const model = options?.model ?? "qwen2.5:1.5b";
+  const baseUrl = "http://localhost:11434";
+
+  try {
+    const response = await fetch(`${baseUrl}/api/generate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model,
+        prompt: options?.systemPrompt
+          ? `${options.systemPrompt}\n\n${prompt}`
+          : prompt,
+        stream: false,
+        options: {
+          temperature: options?.temperature ?? 0.7,
+          num_predict: options?.maxTokens ?? 200,
+        },
+      }),
+      signal: AbortSignal.timeout(options?.timeout ?? 10_000),
+    });
+
+    if (!response.ok) {
+      return {
+        success: false,
+        text: "",
+        error: `HTTP ${response.status}: ${response.statusText}`,
+        latency_ms: Date.now() - startTime,
+      };
+    }
+
+    const data = await response.json();
+    return {
+      success: true,
+      text: data.response || "",
+      latency_ms: Date.now() - startTime,
+    };
+  } catch (e) {
+    return {
+      success: false,
+      text: "",
+      error: String(e),
+      latency_ms: Date.now() - startTime,
+    };
+  }
+}
+
+describe("ollama-client (generateText logic)", () => {
+  beforeEach(() => {
+    originalFetch = global.fetch;
+  });
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+  });
+
+  describe("generateText", () => {
+    it("returns successful response with generated text", async () => {
+      global.fetch = async () =>
+        ({
+          ok: true,
+          json: async () => ({ response: "This is a generated response about coding sessions." }),
+        }) as Response;
+
+      const result = await generateText("How did we fix the bug?", {
+        systemPrompt: "You are a helpful assistant.",
+        maxTokens: 200,
+        timeout: 5000,
+      });
+
+      expect(result.success).to.be.true;
+      expect(result.text).to.equal("This is a generated response about coding sessions.");
+      expect(result.latency_ms).to.be.at.least(0);
+      expect(result.error).to.be.undefined;
+    });
+
+    it("handles HTTP errors gracefully", async () => {
+      global.fetch = async () =>
+        ({
+          ok: false,
+          status: 500,
+          statusText: "Internal Server Error",
+        }) as Response;
+
+      const result = await generateText("test query");
+
+      expect(result.success).to.be.false;
+      expect(result.text).to.equal("");
+      expect(result.error).to.equal("HTTP 500: Internal Server Error");
+      expect(result.latency_ms).to.be.at.least(0);
+    });
+
+    it("handles network errors gracefully", async () => {
+      global.fetch = async () => {
+        throw new Error("Network connection failed");
+      };
+
+      const result = await generateText("test query");
+
+      expect(result.success).to.be.false;
+      expect(result.text).to.equal("");
+      expect(result.error).to.include("Network connection failed");
+      expect(result.latency_ms).to.be.at.least(0);
+    });
+
+    it("handles timeout errors", async () => {
+      global.fetch = async () => {
+        throw new Error("TimeoutError: The operation was aborted");
+      };
+
+      const result = await generateText("test query", { timeout: 100 });
+
+      expect(result.success).to.be.false;
+      expect(result.text).to.equal("");
+      expect(result.error).to.include("aborted");
+    });
+
+    it("uses default temperature and maxTokens when not provided", async () => {
+      let capturedRequest: any;
+      global.fetch = async (url, init) => {
+        capturedRequest = JSON.parse(init?.body as string);
+        return {
+          ok: true,
+          json: async () => ({ response: "test response" }),
+        } as Response;
+      };
+
+      await generateText("test query");
+
+      expect(capturedRequest.options.temperature).to.equal(0.7);
+      expect(capturedRequest.options.num_predict).to.equal(200);
+    });
+
+    it("combines system prompt with user prompt", async () => {
+      let capturedRequest: any;
+      global.fetch = async (url, init) => {
+        capturedRequest = JSON.parse(init?.body as string);
+        return {
+          ok: true,
+          json: async () => ({ response: "test response" }),
+        } as Response;
+      };
+
+      await generateText("user query", { systemPrompt: "system instructions" });
+
+      expect(capturedRequest.prompt).to.equal("system instructions\n\nuser query");
+    });
+
+    it("uses custom model when provided", async () => {
+      let capturedRequest: any;
+      global.fetch = async (url, init) => {
+        capturedRequest = JSON.parse(init?.body as string);
+        return {
+          ok: true,
+          json: async () => ({ response: "test response" }),
+        } as Response;
+      };
+
+      await generateText("test", { model: "custom-model:7b" });
+
+      expect(capturedRequest.model).to.equal("custom-model:7b");
+    });
+
+    it("sets stream to false for non-streaming mode", async () => {
+      let capturedRequest: any;
+      global.fetch = async (url, init) => {
+        capturedRequest = JSON.parse(init?.body as string);
+        return {
+          ok: true,
+          json: async () => ({ response: "test response" }),
+        } as Response;
+      };
+
+      await generateText("test");
+
+      expect(capturedRequest.stream).to.be.false;
+    });
+
+    it("handles empty response text", async () => {
+      global.fetch = async () =>
+        ({
+          ok: true,
+          json: async () => ({ response: "" }),
+        }) as Response;
+
+      const result = await generateText("test");
+
+      expect(result.success).to.be.true;
+      expect(result.text).to.equal("");
+    });
+
+    it("handles missing response field in JSON", async () => {
+      global.fetch = async () =>
+        ({
+          ok: true,
+          json: async () => ({}),
+        }) as Response;
+
+      const result = await generateText("test");
+
+      expect(result.success).to.be.true;
+      expect(result.text).to.equal("");
+    });
+  });
+});

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/embedding-indexer.ts

@@ -13,17 +13,14 @@
  *   bun embedding-indexer.ts --stats                    # Show index statistics
  */
 
-import { readFileSync, existsSync, readdirSync } from "node:fs";
-import { readdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
+import { readdir } from "fs/promises";
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
 import { z } from "zod";
-
-import { logInfo, logWarn, logError } from "./logger.js";
+import { RLM_INDEX_DIR, type SessionIndex } from "./types.js";
+import { logInfo, logWarn, logError, logDebug } from "./logger.js";
 import { checkOllamaHealth, embed } from "./ollama-client.js";
-import { loadTranscript } from "./transcript-loader.js";
-import { RLM_INDEX_DIR } from "./types.js";
 import {
   openVectorDb,
   insertChunks,
@@ -33,6 +30,7 @@ import {
   getStats,
   type ChunkRow,
 } from "./vector-store.js";
+import { loadTranscript } from "./transcript-loader.js";
 
 const HOOK_NAME = "rlm_embed_idx";
 const MAX_EMBED_CHARS = 8000;
@@ -66,12 +64,10 @@ const projectFilter = projectArg ? projectArg.split("=")[1] : null;
 if (isStats) {
   showStats();
 } else if (isBatch) {
-  try {
-    await runBatch();
-  } catch (error) {
-    logError(HOOK_NAME, `Fatal: ${error}`, { stderr: true });
+  runBatch().catch((e) => {
+    logError(HOOK_NAME, `Fatal: ${e}`, { stderr: true });
     process.exitCode = 1;
-  }
+  });
 } else {
   process.stderr.write(
     "Usage: bun embedding-indexer.ts --batch [--limit=N] [--project=name]\n" +
@@ -236,9 +232,9 @@ async function runBatch(): Promise<void> {
           if (embedded % 50 === 0) {
             logInfo(HOOK_NAME, `Progress: ${embedded} sessions embedded`, { stderr: true });
           }
-        } catch (error) {
+        } catch (e) {
           errors++;
-          logWarn(HOOK_NAME, `Error embedding ${indexFile}: ${error}`);
+          logWarn(HOOK_NAME, `Error embedding ${indexFile}: ${e}`);
         }
       }
 

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/hyde.ts

@@ -11,8 +11,9 @@
  * See: Gao et al., "Precise Zero-Shot Dense Retrieval without Relevance Labels" (ACL 2023)
  */
 
+import { generateText } from "./ollama-client.js";
+import { embed, embedOne } from "./ollama-client.js";
 import { logDebug, logInfo, logWarn } from "./logger.js";
-import { generateText , embed, embedOne } from "./ollama-client.js";
 
 const HOOK_NAME = "rlm_hyde";
 
@@ -104,7 +105,7 @@ export async function hydeQueryEmbedding(
   logInfo(HOOK_NAME, `Generating ${config.numResponses} hypothetical responses via Ollama`);
 
   // Step 1: Generate N hypothetical responses in parallel
-  const promises = Array.from({ length: config.numResponses }, (_) =>
+  const promises = Array.from({ length: config.numResponses }, (_, i) =>
     generateText(query, {
       systemPrompt: HYDE_SYSTEM_PROMPT,
       maxTokens: config.maxTokens,