ctxman 3.1.1 → 3.2.7

package/lib/pr/pr-context.js

@@ -17,6 +17,7 @@ import FileUtils from '../utils/file-utils.js';
 import TokenUtils from '../utils/token-utils.js';
 import { redactSecrets } from '../utils/secret-redactor.js';
 import { readFileChecked } from '../utils/safe-read.js';
+import { resolveWorkspaceRepos, enforceWorkspacePolicies } from '../workspace/index.js';
 import PrGit, { bufferToText } from './pr-git.js';
 import {
   parseNameStatus,
@@ -53,6 +54,7 @@ const DEFAULTS = {
   redact: true,
   maxFileBytes: 1024 * 1024,
   maxRelatedTests: 50,
+  repos: null,
 };
 
 // Test files read to look for imports and references: per file, and for all of them
@@ -65,6 +67,7 @@ const FILTER_NAMES = {
   context: '.contextignore',
   'context-include': '.contextinclude',
 };
+const IMPACT_ORDER = { low: 0, medium: 1, high: 2 };
 
 /**
  * Check and complete the options
@@ -273,35 +276,58 @@ function describeDropped(dropped) {
   return labels;
 }
 
-/**
- * Build the review context for a branch, the staged changes or the working tree
- * @param {string} [root=process.cwd()] - Project directory (inside a git work tree); a
- *   subdirectory limits the change to that directory
- * @param {object} [options]
- * @param {string} [options.base] - Base revision (default: origin/HEAD, else main, else master;
- *   HEAD with staged/working)
- * @param {string} [options.head='HEAD'] - Head revision
- * @param {boolean} [options.staged] - Compare the index with the base instead
- * @param {boolean} [options.working] - Compare the working tree (with untracked files)
- * @param {number} [options.unified=3] - Context lines in the diff
- * @param {boolean} [options.diff=true] - Include the unified diff
- * @param {boolean} [options.withTests] - Include related tests' contents
- * @param {boolean} [options.withFiles] - Include changed files' full contents
- * @param {string} [options.ask] - Question appended at the end
- * @param {string} [options.instructions] - Instructions appended at the end
- * @param {number} [options.budget] - Maximum tokens of the output
- * @param {'markdown'|'xml'|'json'} [options.style='markdown']
- * @param {boolean} [options.redact=true] - Mask secrets in contents, diff and commit messages
- * @returns {Promise<object>} `output` (the rendered text), `tokens`, per-section `sections`
- *   token counts, the collected `commits`, `files`, `methods`, `relatedTests`, `stats`,
- *   `budget` (limit, dropped, over), `redactions` and `warnings`
- */
-export async function buildPrContext(root = process.cwd(), options = {}) {
-  const opts = normalizePrOptions(options);
-  const rootPath = path.resolve(root);
-  if (!fs.existsSync(rootPath) || !fs.statSync(rootPath).isDirectory()) {
-    throw new Error(`Not a directory: ${rootPath}`);
+function buildWorkspaceRepoInputs(primaryRoot, extraRepos) {
+  const realPrimary = fs.existsSync(primaryRoot)
+    ? fs.realpathSync(primaryRoot)
+    : path.resolve(primaryRoot);
+  const isContainerOfExtra = extraRepos.some((item) => {
+    const raw = typeof item === 'string' ? item : item?.path;
+    if (typeof raw !== 'string' || !raw.trim()) return false;
+    const resolved = path.resolve(raw);
+    const real = fs.existsSync(resolved) ? fs.realpathSync(resolved) : resolved;
+    return real !== realPrimary && real.startsWith(realPrimary + path.sep);
+  });
+  if (isContainerOfExtra || !PrGit.findRepoRoot(realPrimary)) {
+    return [...extraRepos];
   }
+  return [primaryRoot, ...extraRepos];
+}
+
+function prefixDiffWithAlias(diffText, alias) {
+  if (!diffText) return diffText;
+  return diffText
+    .split('\n')
+    .map((line) => {
+      if (line.startsWith('diff --git a/')) {
+        return line.replace(
+          /^diff --git a\/(.+?) b\/(.+)$/,
+          `diff --git a/${alias}/$1 b/${alias}/$2`
+        );
+      }
+      if (line.startsWith('--- a/')) {
+        return `--- a/${alias}/${line.slice(6)}`;
+      }
+      if (line.startsWith('+++ b/')) {
+        return `+++ b/${alias}/${line.slice(6)}`;
+      }
+      if (line.startsWith('rename from ')) {
+        return `rename from ${alias}/${line.slice(12)}`;
+      }
+      if (line.startsWith('rename to ')) {
+        return `rename to ${alias}/${line.slice(10)}`;
+      }
+      if (line.startsWith('copy from ')) {
+        return `copy from ${alias}/${line.slice(10)}`;
+      }
+      if (line.startsWith('copy to ')) {
+        return `copy to ${alias}/${line.slice(8)}`;
+      }
+      return line;
+    })
+    .join('\n');
+}
+
+function collectSingleRepoPr(rootPath, opts) {
   const repoTop = PrGit.findRepoRoot(rootPath);
   if (!repoTop) throw new Error(`Not inside a git repository: ${rootPath}`);
   const repoRoot = fs.realpathSync(repoTop);
@@ -635,7 +661,10 @@ export async function buildPrContext(root = process.cwd(), options = {}) {
     );
   }
 
-  // --- render within the budget ------------------------------------------------------------
+  return { model, scope, redactions, warnings };
+}
+
+function renderModelWithinBudget(model, opts, redactions, warnings, scope) {
   const count = (text) => TokenUtils.calculate(text, 'pr-context.md');
   const dropped = {
     contents: [],
@@ -691,6 +720,7 @@ export async function buildPrContext(root = process.cwd(), options = {}) {
   }
 
   return {
+    ...(model.repos ? { repos: model.repos } : {}),
     output: result.output,
     tokens: result.tokens,
     style: opts.style,
@@ -704,8 +734,9 @@ export async function buildPrContext(root = process.cwd(), options = {}) {
     budget: model.budget,
     commits: model.commits,
     files: model.files,
-    methods: { changed: methods, deleted: deletedMethods },
-    relatedTests: tests.map(({ path: testPath, reasons, changed, excluded }) => ({
+    methods: { changed: model.methods, deleted: model.deletedMethods },
+    relatedTests: model.tests.map(({ path: testPath, reasons, changed, excluded, repo }) => ({
+      ...(repo ? { repo } : {}),
       path: testPath,
       reasons,
       changed,
@@ -716,6 +747,236 @@ export async function buildPrContext(root = process.cwd(), options = {}) {
   };
 }
 
+/**
+ * Build the review context for a branch, the staged changes or the working tree
+ * @param {string} [root=process.cwd()] - Project directory (inside a git work tree); a
+ *   subdirectory limits the change to that directory
+ * @param {object} [options]
+ * @param {string} [options.base] - Base revision (default: origin/HEAD, else main, else master;
+ *   HEAD with staged/working)
+ * @param {string} [options.head='HEAD'] - Head revision
+ * @param {boolean} [options.staged] - Compare the index with the base instead
+ * @param {boolean} [options.working] - Compare the working tree (with untracked files)
+ * @param {number} [options.unified=3] - Context lines in the diff
+ * @param {boolean} [options.diff=true] - Include the unified diff
+ * @param {boolean} [options.withTests] - Include related tests' contents
+ * @param {boolean} [options.withFiles] - Include changed files' full contents
+ * @param {string} [options.ask] - Question appended at the end
+ * @param {string} [options.instructions] - Instructions appended at the end
+ * @param {number} [options.budget] - Maximum tokens of the output
+ * @param {'markdown'|'xml'|'json'} [options.style='markdown']
+ * @param {boolean} [options.redact=true] - Mask secrets in contents, diff and commit messages
+ * @param {Array<string|{path: string, alias?: string}>} [options.repos] - Additional workspace repositories
+ * @returns {Promise<object>} `output` (the rendered text), `tokens`, per-section `sections`
+ *   token counts, the collected `commits`, `files`, `methods`, `relatedTests`, `stats`,
+ *   `budget` (limit, dropped, over), `redactions` and `warnings`
+ */
+export async function buildPrContext(root = process.cwd(), options = {}) {
+  const opts = normalizePrOptions(options);
+  const rootPath = path.resolve(root);
+  if (!fs.existsSync(rootPath) || !fs.statSync(rootPath).isDirectory()) {
+    throw new Error(`Not a directory: ${rootPath}`);
+  }
+
+  const isWorkspace = Array.isArray(options.repos) && options.repos.length > 0;
+  if (!isWorkspace) {
+    const { model, scope, redactions, warnings } = collectSingleRepoPr(rootPath, opts);
+    return renderModelWithinBudget(model, opts, redactions, warnings, scope);
+  }
+
+  const resolvedRepos = resolveWorkspaceRepos(buildWorkspaceRepoInputs(rootPath, options.repos));
+  enforceWorkspacePolicies(resolvedRepos, {
+    filesByRepo: new Map(),
+    tokens: 0,
+    redact: opts.redact,
+  });
+
+  for (const repo of resolvedRepos) {
+    if (!PrGit.findRepoRoot(repo.realRoot)) {
+      throw new Error(`Not inside a git repository: ${repo.root}`);
+    }
+  }
+
+  const perRepoResults = [];
+  const skippedErrors = [];
+  let firstError = null;
+
+  for (const repo of resolvedRepos) {
+    try {
+      const single = collectSingleRepoPr(repo.root, { ...opts, budget: null });
+      perRepoResults.push({ repo, ...single });
+    } catch (error) {
+      if (error.name === 'PolicyConfigError' || error.name === 'PolicyViolationError') {
+        throw error;
+      }
+      firstError ??= error;
+      skippedErrors.push({ repo, error });
+    }
+  }
+
+  if (perRepoResults.length === 0 && firstError) {
+    throw firstError;
+  }
+
+  const warnings = [];
+  for (const { repo, error } of skippedErrors) {
+    warnings.push(`${repo.alias}: skipped (${error.message})`);
+  }
+
+  const redactions = {};
+  const commits = [];
+  const files = [];
+  const methods = [];
+  const deletedMethods = [];
+  const diffs = [];
+  const allTests = [];
+  const contents = [];
+  const byStatus = {};
+  const filesByRepo = new Map(resolvedRepos.map((r) => [r.alias, []]));
+
+  let highestImpact = { level: 'low', score: 0 };
+
+  for (const { repo, model: m, redactions: r, warnings: w } of perRepoResults) {
+    for (const [type, count] of Object.entries(r)) {
+      redactions[type] = (redactions[type] || 0) + count;
+    }
+    for (const warning of w) {
+      warnings.push(`${repo.alias}: ${warning}`);
+    }
+    if (
+      (IMPACT_ORDER[m.impact.level] ?? 0) > (IMPACT_ORDER[highestImpact.level] ?? 0) ||
+      m.impact.score > highestImpact.score
+    ) {
+      highestImpact = {
+        level:
+          (IMPACT_ORDER[m.impact.level] ?? 0) >= (IMPACT_ORDER[highestImpact.level] ?? 0)
+            ? m.impact.level
+            : highestImpact.level,
+        score: Math.max(highestImpact.score, m.impact.score),
+      };
+    }
+    for (const [status, cnt] of Object.entries(m.stats.byStatus)) {
+      byStatus[status] = (byStatus[status] || 0) + cnt;
+    }
+    for (const c of m.commits) {
+      commits.push({ ...c, repo: repo.alias });
+    }
+    for (const f of m.files) {
+      filesByRepo.get(repo.alias)?.push({ path: f.path, tokens: 0 });
+      files.push({
+        ...f,
+        repo: repo.alias,
+        path: `${repo.alias}/${f.path}`,
+        oldPath: f.oldPath ? `${repo.alias}/${f.oldPath}` : null,
+      });
+    }
+    for (const method of m.methods) {
+      methods.push({
+        ...method,
+        repo: repo.alias,
+        file: `${repo.alias}/${method.file}`,
+      });
+    }
+    for (const dm of m.deletedMethods) {
+      deletedMethods.push({
+        ...dm,
+        repo: repo.alias,
+        file: `${repo.alias}/${dm.file}`,
+      });
+    }
+    for (const d of m.diffs) {
+      diffs.push({
+        ...d,
+        repo: repo.alias,
+        path: `${repo.alias}/${d.path}`,
+        text: prefixDiffWithAlias(d.text, repo.alias),
+      });
+    }
+    for (const t of m.tests) {
+      allTests.push({
+        ...t,
+        repo: repo.alias,
+        path: `${repo.alias}/${t.path}`,
+      });
+    }
+    for (const c of m.contents) {
+      contents.push({
+        ...c,
+        repo: repo.alias,
+        path: `${repo.alias}/${c.path}`,
+      });
+    }
+  }
+
+  const tests = allTests.slice(0, opts.maxRelatedTests);
+  if (allTests.length > tests.length) {
+    warnings.push(
+      `${allTests.length} related tests found across workspace; the first ${tests.length} are listed`
+    );
+  }
+
+  const uniqueJoin = (values) => [...new Set(values.filter(Boolean))].join(', ');
+  const firstModel = perRepoResults[0].model;
+  const baseRef = uniqueJoin(perRepoResults.map((x) => x.model.base.ref));
+  const baseShort = uniqueJoin(perRepoResults.map((x) => x.model.base.short));
+  const headRef = uniqueJoin(perRepoResults.map((x) => x.model.head.ref));
+  const headShort = uniqueJoin(perRepoResults.map((x) => x.model.head.short));
+  const mergeShort = uniqueJoin(perRepoResults.map((x) => x.model.mergeBase.short));
+
+  const workspaceModel = {
+    repos: resolvedRepos.map(({ alias, root: r }) => ({ alias, root: r })),
+    mode: firstModel.mode,
+    base: { ref: baseRef, sha: firstModel.base.sha, short: baseShort || null },
+    head:
+      firstModel.mode === 'range'
+        ? { ref: headRef, sha: firstModel.head.sha, short: headShort || null }
+        : { ref: headRef, sha: null, short: null },
+    mergeBase: { sha: firstModel.mergeBase.sha, short: mergeShort },
+    scope: '',
+    impact: highestImpact,
+    stats: {
+      commits: commits.length,
+      files: files.length,
+      byStatus,
+      additions: files.reduce((sum, f) => sum + f.additions, 0),
+      deletions: files.reduce((sum, f) => sum + f.deletions, 0),
+      excluded: files.filter((f) => f.excluded).length,
+      changedMethods: methods.length,
+      addedMethods: methods.filter((m) => m.change === 'added').length,
+      deletedMethods: deletedMethods.length,
+      relatedTests: tests.length,
+    },
+    commits,
+    files,
+    methods,
+    deletedMethods,
+    diffEnabled: opts.diff,
+    diffs,
+    tests,
+    withTests: opts.withTests,
+    withFiles: opts.withFiles,
+    contents,
+    instructions: opts.instructions,
+    ask: opts.ask,
+    budget: opts.budget ? { limit: opts.budget, dropped: [], over: false } : null,
+    tokens: null,
+    logBodiesDropped: false,
+    logDropped: false,
+    filesDropped: false,
+    methodsDropped: false,
+  };
+
+  const rendered = renderModelWithinBudget(workspaceModel, opts, redactions, warnings, '');
+
+  enforceWorkspacePolicies(resolvedRepos, {
+    filesByRepo,
+    tokens: rendered.tokens,
+    redact: opts.redact,
+  });
+
+  return rendered;
+}
+
 /**
  * What the budget drops, least important first: full file contents, test contents, related
  * test paths, per-file diffs, method sources, the methods list, commit bodies, the commit

package/lib/pr/pr-renderer.js

@@ -140,6 +140,9 @@ const linesLabel = (item) =>
 export function summaryFacts(model) {
   const { stats } = model;
   const facts = [];
+  if (Array.isArray(model.repos) && model.repos.length > 0) {
+    facts.push(['Repositories', model.repos.map((r) => r.alias).join(', ')]);
+  }
   if (model.mode === 'range') {
     facts.push(['Base', `${model.base.ref} (${model.base.short})`]);
     facts.push(['Head', `${model.head.ref} (${model.head.short})`]);
@@ -206,7 +209,8 @@ const markdown = {
   },
 
   commit(commit, model) {
-    let text = `### ${code(commit.short)} ${commit.subject}\n${commit.author}, ${commit.date}`;
+    const repoBadge = commit.repo ? `[${commit.repo}] ` : '';
+    let text = `### ${code(commit.short)} ${repoBadge}${commit.subject}\n${commit.author}, ${commit.date}`;
     if (commit.body && !model.logBodiesDropped) {
       text += `\n\n${commit.body
         .split('\n')
@@ -229,7 +233,7 @@ const markdown = {
     const rows = model.files.map((file) => {
       const name =
         file.oldPath && file.oldPath !== file.path && (file.status === 'R' || file.status === 'C')
-          ? `${code(file.oldPath)} → ${code(file.path)}`
+          ? `${code(file.oldPath)} \u2192 ${code(file.path)}`
           : code(file.path);
       const note = file.excluded ? ` (content excluded by ${file.excluded})` : '';
       const added = file.binary ? 'binary' : file.additions;
@@ -344,8 +348,9 @@ function createXml() {
     },
 
     commit(commit, model) {
+      const repoAttr = commit.repo ? ` repo="${escapeAttr(commit.repo)}"` : '';
       const body = commit.body && !model.logBodiesDropped ? `\n\n${commit.body}` : '';
-      return `<commit sha="${commit.short}" author="${escapeAttr(commit.author)}" date="${commit.date}">\n${commit.subject}${body}\n</commit>`;
+      return `<commit sha="${commit.short}"${repoAttr} author="${escapeAttr(commit.author)}" date="${commit.date}">\n${commit.subject}${body}\n</commit>`;
     },
 
     commits(model) {
@@ -468,6 +473,7 @@ function createXml() {
 const json = {
   summary(model) {
     const summary = {
+      ...(Array.isArray(model.repos) && model.repos.length > 0 ? { repos: model.repos } : {}),
       mode: model.mode,
       base: model.base,
       head: model.head,
@@ -483,10 +489,11 @@ const json = {
   },
 
   commit(commit, model) {
-    const { sha, short, author, date, subject, body } = commit;
-    return model.logBodiesDropped
-      ? { sha, short, author, date, subject }
-      : { sha, short, author, date, subject, body };
+    const { sha, short, author, date, subject, body, repo } = commit;
+    const base = repo
+      ? { repo, sha, short, author, date, subject }
+      : { sha, short, author, date, subject };
+    return model.logBodiesDropped ? base : { ...base, body };
   },
 
   commits(model) {
@@ -497,6 +504,7 @@ const json = {
   files(model) {
     if (model.filesDropped) return null;
     return model.files.map((file) => ({
+      ...(file.repo ? { repo: file.repo } : {}),
       status: file.status,
       path: file.path,
       oldPath: file.oldPath,
@@ -510,8 +518,9 @@ const json = {
   },
 
   method(method) {
-    const { file, name, start, end, change, changedLines } = method;
+    const { file, name, start, end, change, changedLines, repo } = method;
     return {
+      ...(repo ? { repo } : {}),
       file,
       name,
       start,
@@ -527,7 +536,8 @@ const json = {
     if (model.methods.length === 0 && model.deletedMethods.length === 0) return null;
     return {
       changed: model.methods.map(json.method),
-      deleted: model.deletedMethods.map(({ file, name, start, end }) => ({
+      deleted: model.deletedMethods.map(({ file, name, start, end, repo }) => ({
+        ...(repo ? { repo } : {}),
         file,
         name,
         start,
@@ -548,7 +558,12 @@ const json = {
   },
 
   testLine(test) {
-    const entry = { path: test.path, reasons: test.reasons, changed: test.changed };
+    const entry = {
+      ...(test.repo ? { repo: test.repo } : {}),
+      path: test.path,
+      reasons: test.reasons,
+      changed: test.changed,
+    };
     if (test.excluded) entry.contentExcludedBy = test.excluded;
     return entry;
   },

package/lib/rag/EmbeddingProvider.js

@@ -5,13 +5,103 @@ export class EmbeddingProvider {
   /**
    * Generates an embedding for the given text.
    * @param {string} text
-   * @returns {Promise<number[]>}
-   */
+   * @returns {Promise<number[]>}\n   */
   async embed(_text) {
     throw new Error('Not implemented');
   }
 }
 
+/**
+ * Deterministic, zero-dependency local embedding provider (256 dimensions).
+ * Uses feature-hashing over identifier tokens and character trigrams with L2 normalization.
+ * Requires zero external packages and works 100% offline.
+ */
+export class LocalHashEmbeddingProvider extends EmbeddingProvider {
+  constructor(dimension = 256) {
+    super();
+    this.dimension = dimension;
+  }
+
+  /**
+   * 32-bit FNV-1a hash function with optional seed.
+   * @private
+   */
+  _hash(str, seed = 0x811c9dc5) {
+    let h = seed >>> 0;
+    for (let i = 0; i < str.length; i++) {
+      h ^= str.charCodeAt(i);
+      h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h >>> 0;
+  }
+
+  /**
+   * Generates a deterministic 256-dim L2-normalized embedding for the given text.
+   * @param {string} text
+   * @returns {Promise<number[]>}
+   */
+  async embed(text) {
+    const raw = String(text ?? '');
+    const vector = new Float64Array(this.dimension);
+
+    // 1. Extract identifier tokens
+    const tokens = raw.match(/[a-zA-Z0-9_$]+/g) || [];
+    for (const token of tokens) {
+      const lower = token.toLowerCase();
+      // Hash whole token
+      const h1 = this._hash(lower, 0x12345678);
+      const idx1 = h1 % this.dimension;
+      const sign1 = (this._hash(lower, 0x87654321) & 1) === 0 ? 1 : -1;
+      vector[idx1] += sign1 * 1.5;
+
+      // Split camelCase/snake_case sub-tokens if composite
+      const subTokens = token.replace(/([a-z])([A-Z])/g, '$1 $2').split(/[_\s]+/);
+      if (subTokens.length > 1) {
+        for (const sub of subTokens) {
+          if (sub.length > 1) {
+            const subLower = sub.toLowerCase();
+            const hSub = this._hash(subLower, 0x2468ace0);
+            const idxSub = hSub % this.dimension;
+            const signSub = (this._hash(subLower, 0x0eca8642) & 1) === 0 ? 1 : -1;
+            vector[idxSub] += signSub * 1.0;
+          }
+        }
+      }
+    }
+
+    // 2. Extract character trigrams
+    const normalized = raw.toLowerCase().replace(/\s+/g, ' ');
+    if (normalized.length >= 3) {
+      for (let i = 0; i <= normalized.length - 3; i++) {
+        const trigram = normalized.slice(i, i + 3);
+        const hTri = this._hash(trigram, 0x13579bdf);
+        const idxTri = hTri % this.dimension;
+        const signTri = (this._hash(trigram, 0xfdb97531) & 1) === 0 ? 1 : -1;
+        vector[idxTri] += signTri * 1.0;
+      }
+    } else if (normalized.length > 0) {
+      const hShort = this._hash(normalized, 0x99887766);
+      const idxShort = hShort % this.dimension;
+      const signShort = (this._hash(normalized, 0x66778899) & 1) === 0 ? 1 : -1;
+      vector[idxShort] += signShort * 1.0;
+    }
+
+    // 3. L2 normalize
+    let sumSq = 0;
+    for (let i = 0; i < this.dimension; i++) {
+      sumSq += vector[i] * vector[i];
+    }
+    const norm = Math.sqrt(sumSq);
+    if (norm > 0) {
+      for (let i = 0; i < this.dimension; i++) {
+        vector[i] /= norm;
+      }
+    }
+
+    return Array.from(vector);
+  }
+}
+
 /**
  * Uses @xenova/transformers to generate embeddings locally using ONNX models.
  * Default model: Xenova/all-MiniLM-L6-v2 (384 dimensions)
@@ -53,6 +143,53 @@ export class TransformersEmbeddingProvider extends EmbeddingProvider {
   }
 }
 
+/**
+ * Tries TransformersEmbeddingProvider if @xenova/transformers is installed
+ * and CTXMAN_EMBEDDER !== 'local'; otherwise seamlessly falls back to
+ * LocalHashEmbeddingProvider without network or model loading failure.
+ */
+export class AutoEmbeddingProvider extends EmbeddingProvider {
+  /**
+   * @param {object} [options]
+   * @param {string} [options.modelName]
+   */
+  constructor(options = {}) {
+    super();
+    this.modelName = options.modelName;
+    this.activeProvider = null;
+  }
+
+  async init() {
+    if (this.activeProvider) return;
+
+    if (process.env.CTXMAN_EMBEDDER === 'local') {
+      this.activeProvider = new LocalHashEmbeddingProvider();
+      return;
+    }
+
+    try {
+      await import('@xenova/transformers');
+    } catch (err) {
+      if (err.code === 'ERR_MODULE_NOT_FOUND') {
+        this.activeProvider = new LocalHashEmbeddingProvider();
+        return;
+      }
+      throw err;
+    }
+
+    const provider = new TransformersEmbeddingProvider(this.modelName);
+    await provider.init();
+    this.activeProvider = provider;
+  }
+
+  async embed(text) {
+    if (!this.activeProvider) {
+      await this.init();
+    }
+    return this.activeProvider.embed(text);
+  }
+}
+
 /**
  * Mock provider for testing without loading heavy models.
  */

package/lib/rag/VectorStoreFactory.js

@@ -1,15 +1,19 @@
+import { SqliteVectorStore } from './stores/SqliteVectorStore.js';
 import { LanceDBStore } from './stores/LanceDBStore.js';
 import { ChromaDBStore } from './stores/ChromaDBStore.js';
 import { PineconeStore } from './stores/PineconeStore.js';
 
 export class VectorStoreFactory {
   /**
-   * @param {string} type
+   * @param {string} [type='sqlite']
    * @param {import('./EmbeddingProvider').EmbeddingProvider} embeddingProvider
-   * @param {Object} config
+   * @param {Object} [config={}]
    */
-  static create(type, embeddingProvider, config = {}) {
-    switch (type.toLowerCase()) {
+  static create(type = 'sqlite', embeddingProvider, config = {}) {
+    const storeType = (type || 'sqlite').toLowerCase();
+    switch (storeType) {
+      case 'sqlite':
+        return new SqliteVectorStore(embeddingProvider, config.path || config.storagePath);
       case 'lancedb':
         return new LanceDBStore(embeddingProvider, config.path);
       case 'chroma':
@@ -22,3 +26,5 @@ export class VectorStoreFactory {
     }
   }
 }
+
+export default VectorStoreFactory;