devbrain-cli 0.2.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/xml-naming/src/index.js

@@ -0,0 +1,270 @@
+/**
+ * xml-naming
+ * Validates XML Name productions as defined in the XML 1.0 and 1.1 specifications.
+ * Covers: Name, NCName, QName, NMToken, NMTokens
+ *
+ * XML 1.0 spec: https://www.w3.org/TR/xml/#NT-Name
+ * XML 1.1 spec: https://www.w3.org/TR/xml11/#NT-NameStartChar
+ * XML NS spec:  https://www.w3.org/TR/xml-names/#NT-NCName
+ */
+
+// ---------------------------------------------------------------------------
+// Character class strings — XML 1.0
+//
+// NameStartChar ::= ":" | [A-Z] | "_" | [a-z]
+//   | [#xC0-#xD6]   | [#xD8-#xF6]   | [#xF8-#x2FF]
+//   | [#x370-#x37D] | [#x37F-#x1FFF]    <- split to exclude #x0487
+//   | [#x200C-#x200D]
+//   | [#x2070-#x218F] | [#x2C00-#x2FEF]
+//   | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD]
+//
+// NameChar ::= NameStartChar | "-" | "." | [0-9]
+//   | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
+//
+// Note: \u0487 (Combining Cyrillic Millions Sign) was added in Unicode 4.0,
+// after XML 1.0 was defined against Unicode 2.0. It falls inside the range
+// \u037F-\u1FFF but must be excluded. We split that range into
+// \u037F-\u0486 and \u0488-\u1FFF to exclude it explicitly.
+// ---------------------------------------------------------------------------
+
+const nameStartChar10 =
+  ':A-Za-z_' +
+  '\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF' +
+  '\u0370-\u037D' +
+  '\u037F-\u0486\u0488-\u1FFF' +  // split to exclude \u0487
+  '\u200C-\u200D' +
+  '\u2070-\u218F' +
+  '\u2C00-\u2FEF' +
+  '\u3001-\uD7FF' +
+  '\uF900-\uFDCF' +
+  '\uFDF0-\uFFFD';
+
+const nameChar10 =
+  nameStartChar10 +
+  '\\-\\.\\d' +
+  '\u00B7' +
+  '\u0300-\u036F' +
+  '\u203F-\u2040';
+
+// ---------------------------------------------------------------------------
+// Character class strings — XML 1.1
+//
+// Differences from XML 1.0:
+//
+// NameStartChar:
+//   1.0 has split ranges: \u00C0-\u00D6, \u00D8-\u00F6, \u00F8-\u02FF
+//   1.1 merges them into: \u00C0-\u02FF
+//   (\u00D7 x and \u00F7 / are division symbols, excluded in both versions)
+//
+//   1.0 tops out at \uFFFD (BMP only)
+//   1.1 adds \u{10000}-\u{EFFFF} (supplementary planes)
+//   These require the /u flag on the RegExp — see buildRegexes below.
+//
+// NameChar:
+//   1.1 adds \u0487 (Combining Cyrillic Millions Sign, added in Unicode 4.0)
+// ---------------------------------------------------------------------------
+
+const nameStartChar11 =
+  ':A-Za-z_' +
+  '\u00C0-\u02FF' +                    // merged — 1.0 had three split ranges here
+  '\u0370-\u037D' +
+  '\u037F-\u0486\u0488-\u1FFF' +       // split to exclude \u0487 (combining mark, never a NameStartChar)
+  '\u200C-\u200D' +
+  '\u2070-\u218F' +
+  '\u2C00-\u2FEF' +
+  '\u3001-\uD7FF' +
+  '\uF900-\uFDCF' +
+  '\uFDF0-\uFFFD' +
+  '\u{10000}-\u{EFFFF}';     // supplementary planes — REQUIRES /u flag on RegExp
+
+const nameChar11 =
+  nameStartChar11 +
+  '\\-\\.\\d' +
+  '\u00B7' +
+  '\u0300-\u036F' +
+  '\u0487' +                 // Combining Cyrillic Millions Sign — valid in 1.1, not 1.0
+  '\u203F-\u2040';
+
+// ---------------------------------------------------------------------------
+// Regex builders
+//
+// XML 1.0 regexes: no flags — BMP only, standard JS regex behaviour.
+// XML 1.1 regexes: /u flag — required for \u{10000}-\u{EFFFF} to match actual
+//   supplementary code points rather than lone surrogates (which are illegal XML).
+// ---------------------------------------------------------------------------
+
+const buildRegexes = (startChar, char, flags = '') => {
+  const ncStart = startChar.replace(':', '');
+  const ncChar = char.replace(':', '');
+  const ncNamePat = `[${ncStart}][${ncChar}]*`;
+
+  return {
+    name: new RegExp(`^[${startChar}][${char}]*$`, flags),
+    ncName: new RegExp(`^${ncNamePat}$`, flags),
+    qName: new RegExp(`^${ncNamePat}(?::${ncNamePat})?$`, flags),
+    nmToken: new RegExp(`^[${char}]+$`, flags),
+    nmTokens: new RegExp(`^[${char}]+(?:\\s+[${char}]+)*$`, flags),
+  };
+};
+
+const regexes10 = buildRegexes(nameStartChar10, nameChar10);       // no /u — BMP only
+const regexes11 = buildRegexes(nameStartChar11, nameChar11, 'u');  // /u — enables \u{10000}-\u{EFFFF}
+
+const getRegexes = (xmlVersion = '1.0') =>
+  xmlVersion === '1.1' ? regexes11 : regexes10;
+
+// ---------------------------------------------------------------------------
+// Boolean validators
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true if the string is a valid XML Name.
+ * Colons are allowed anywhere (Name production).
+ * Used for: DOCTYPE entity names, notation names, DTD element declarations.
+ */
+export const name = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).name.test(str);
+
+/**
+ * Returns true if the string is a valid NCName (Non-Colonized Name).
+ * Colons are not permitted.
+ * Used for: namespace prefixes, local names, SVG id attributes.
+ */
+export const ncName = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).ncName.test(str);
+
+/**
+ * Returns true if the string is a valid QName (Qualified Name).
+ * Allows exactly one colon as a prefix separator: prefix:localName.
+ * Used for: element and attribute names in namespace-aware XML/SVG.
+ */
+export const qName = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).qName.test(str);
+
+/**
+ * Returns true if the string is a valid NMToken.
+ * Like Name but no restriction on the first character.
+ * Used for: DTD NMTOKEN attribute values.
+ */
+export const nmToken = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).nmToken.test(str);
+
+/**
+ * Returns true if the string is a valid NMTokens value.
+ * A whitespace-separated list of NMToken values.
+ * Used for: DTD NMTOKENS attribute values.
+ */
+export const nmTokens = (str, { xmlVersion = '1.0' } = {}) =>
+  getRegexes(xmlVersion).nmTokens.test(str);
+
+// ---------------------------------------------------------------------------
+// Diagnostic validator
+// ---------------------------------------------------------------------------
+
+const PRODUCTIONS = ['name', 'ncName', 'qName', 'nmToken', 'nmTokens'];
+
+/**
+ * Validates a string against a named production and returns a detailed result.
+ *
+ * @param {string} str
+ * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production
+ * @param {{ xmlVersion?: '1.0'|'1.1' }} [opts]
+ * @returns {{ valid: boolean, production: string, input: string, reason?: string, position?: number }}
+ */
+export const validate = (str, production, { xmlVersion = '1.0' } = {}) => {
+  if (!PRODUCTIONS.includes(production)) {
+    throw new TypeError(
+      `Unknown production "${production}". Must be one of: ${PRODUCTIONS.join(', ')}`
+    );
+  }
+
+  const validators = { name, ncName, qName, nmToken, nmTokens };
+  const isValid = validators[production](str, { xmlVersion });
+
+  if (isValid) return { valid: true, production, input: str };
+
+  let reason = 'Does not match the production rules';
+  let position;
+
+  if (str.length === 0) {
+    reason = 'Input is empty';
+  } else if (production === 'ncName' && str.includes(':')) {
+    position = str.indexOf(':');
+    reason = 'Colon is not allowed in NCName';
+  } else if (production === 'qName' && str.startsWith(':')) {
+    reason = 'QName cannot start with a colon';
+    position = 0;
+  } else if (production === 'qName' && str.endsWith(':')) {
+    reason = 'QName cannot end with a colon';
+    position = str.length - 1;
+  } else if (production === 'qName' && (str.match(/:/g) || []).length > 1) {
+    reason = 'QName can have at most one colon';
+    position = str.lastIndexOf(':');
+  } else if (
+    ['name', 'ncName', 'qName'].includes(production) &&
+    !/^[:A-Za-z_\u00C0-\uFFFD]/.test(str[0])
+  ) {
+    reason = `First character "${str[0]}" is not a valid NameStartChar`;
+    position = 0;
+  } else {
+    for (let i = 0; i < str.length; i++) {
+      if (!/[\w\-\\.:\u00B7\u00C0-\uFFFD]/.test(str[i])) {
+        reason = `Character "${str[i]}" at position ${i} is not a valid NameChar`;
+        position = i;
+        break;
+      }
+    }
+  }
+
+  return { valid: false, production, input: str, reason, position };
+};
+
+// ---------------------------------------------------------------------------
+// Batch validator
+// ---------------------------------------------------------------------------
+
+/**
+ * Validates an array of strings against a named production.
+ *
+ * @param {string[]} strings
+ * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production
+ * @param {{ xmlVersion?: '1.0'|'1.1' }} [opts]
+ * @returns {Array<{ valid: boolean, production: string, input: string, reason?: string, position?: number }>}
+ */
+export const validateAll = (strings, production, opts = {}) =>
+  strings.map(str => validate(str, production, opts));
+
+// ---------------------------------------------------------------------------
+// Sanitizer
+// ---------------------------------------------------------------------------
+
+/**
+ * Transforms an invalid string into the nearest valid XML name for the given production.
+ *
+ * @param {string} str
+ * @param {'name'|'ncName'|'qName'|'nmToken'|'nmTokens'} production
+ * @param {{ replacement?: string }} [opts]
+ * @returns {string}
+ */
+export const sanitize = (str, production = 'name', { replacement = '_' } = {}) => {
+  if (!str) return replacement;
+
+  let result = str;
+
+  // Strip colons for NCName
+  if (production === 'ncName') {
+    result = result.replace(/:/g, '');
+  }
+
+  // Replace illegal characters
+  result = result.replace(/[^\w\-\.:\u00B7\u00C0-\uFFFD]/g, replacement);
+
+  // Fix invalid start character for Name / NCName / QName
+  if (production !== 'nmToken' && production !== 'nmTokens') {
+    if (/^[\-\.\d]/.test(result)) {
+      result = replacement + result;
+    }
+  }
+
+  return result || replacement;
+};

package/dist/temp-prefix/node_modules/devbrain-cli/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "devbrain-cli",
+  "version": "0.3.0",
+  "description": "Offline-first CLI tool providing persistent, deterministic project memory for AI assistants.",
+  "keywords": [
+    "devbrain",
+    "cli",
+    "ai",
+    "context",
+    "memory",
+    "offline"
+  ],
+  "homepage": "https://github.com/CodeItAlone/devbrain#readme",
+  "bugs": {
+    "url": "https://github.com/CodeItAlone/devbrain/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/CodeItAlone/devbrain.git"
+  },
+  "license": "MIT",
+  "author": "Subrato Kundu (https://github.com/CodeItAlone/devbrain)",
+  "type": "module",
+  "main": "./dist/bin.js",
+  "types": "./dist/bin.d.ts",
+  "bin": {
+    "devbrain": "dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/bin.js",
+      "types": "./dist/bin.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "compile": "tsc --build",
+    "prepack": "node ../../scripts/prepare-cli.js"
+  },
+  "dependencies": {
+    "@devbrain/core": "^0.3.0",
+    "@devbrain/shared": "^0.3.0",
+    "@huggingface/transformers": "^4.2.0",
+    "commander": "^12.0.0",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.1",
+    "fast-glob": "^3.3.2",
+    "fast-xml-parser": "^5.9.3",
+    "simple-git": "^3.23.0"
+  },
+  "bundleDependencies": [
+    "@devbrain/core",
+    "@devbrain/shared"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/node_modules/@devbrain/core/dist/embeddings/EmbeddingProvider.d.ts

@@ -0,0 +1,4 @@
+export interface EmbeddingProvider {
+    generateEmbedding(text: string): Promise<number[]>;
+    generateEmbeddings(texts: string[]): Promise<number[][]>;
+}

package/node_modules/@devbrain/core/dist/embeddings/EmbeddingProvider.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=EmbeddingProvider.js.map

package/node_modules/@devbrain/core/dist/embeddings/TransformersProvider.d.ts

@@ -0,0 +1,9 @@
+import { EmbeddingProvider } from './EmbeddingProvider.js';
+export declare class TransformersProvider implements EmbeddingProvider {
+    private pipelineInstance;
+    private modelName;
+    constructor(modelName?: string);
+    private getPipeline;
+    generateEmbedding(text: string): Promise<number[]>;
+    generateEmbeddings(texts: string[]): Promise<number[][]>;
+}

package/node_modules/@devbrain/core/dist/embeddings/TransformersProvider.js

@@ -0,0 +1,70 @@
+import os from 'node:os';
+import path from 'node:path';
+export class TransformersProvider {
+    pipelineInstance = null;
+    modelName;
+    constructor(modelName = 'onnx-community/all-MiniLM-L6-v2-ONNX') {
+        // We default to 'onnx-community/all-MiniLM-L6-v2-ONNX' or 'Xenova/all-MiniLM-L6-v2'
+        this.modelName = modelName;
+    }
+    async getPipeline() {
+        if (this.pipelineInstance) {
+            return this.pipelineInstance;
+        }
+        try {
+            // Lazy load @huggingface/transformers
+            const { pipeline, env } = await import('@huggingface/transformers');
+            // Configure transformers cache globally
+            const globalDevBrainHome = path.join(os.homedir(), '.devbrain');
+            const cacheDir = path.join(globalDevBrainHome, 'models');
+            env.cacheDir = cacheDir;
+            // Prevent remote model downloads from hanging in test environments
+            if (process.env.VITEST || process.env.NODE_ENV === 'test') {
+                throw new Error('Network connection disabled in test environment.');
+            }
+            // Feature extraction pipeline
+            this.pipelineInstance = await pipeline('feature-extraction', this.modelName);
+            return this.pipelineInstance;
+        }
+        catch (error) {
+            const msg = error.message || '';
+            let errorType = 'Embedding Model Load Failure';
+            let diagnostics = 'Ensure you have an active internet connection for the first run, or that the model is present in the cache.';
+            if (msg.includes('Unauthorized') || msg.includes('401') || msg.includes('forbidden')) {
+                errorType = 'Authentication Error';
+                diagnostics = 'The model repository appears to be private, requires authentication tokens, or is unauthorized.';
+            }
+            else if (msg.includes('404') || msg.includes('not found') || msg.includes('Cannot find')) {
+                errorType = 'Invalid Model Identifier';
+                diagnostics = `The model repository '${this.modelName}' does not exist on Hugging Face. Check for spelling errors or missing ONNX suffixes.`;
+            }
+            else if (msg.includes('fetch') || msg.includes('network') || msg.includes('connect') || msg.includes('offline') || msg.includes('getaddrinfo') || msg.includes('timeout')) {
+                errorType = 'Network Connection Failure';
+                diagnostics = 'Failed to connect to Hugging Face Hub to download model files. Subsequent runs will function offline once downloaded.';
+            }
+            else if (msg.includes('cache') || msg.includes('corrupt') || msg.includes('integrity') || msg.includes('checksum')) {
+                errorType = 'Cache Corruption Error';
+                diagnostics = 'The cached model files are corrupt. Try clearing the global model cache directory at ~/.devbrain/models/.';
+            }
+            throw new Error(`[${errorType}] ${error.message}\nFix: ${diagnostics}`);
+        }
+    }
+    async generateEmbedding(text) {
+        const extractor = await this.getPipeline();
+        const output = await extractor(text, { pooling: 'mean', normalize: true });
+        return Array.from(output.data);
+    }
+    async generateEmbeddings(texts) {
+        if (texts.length === 0)
+            return [];
+        const extractor = await this.getPipeline();
+        const results = [];
+        // Batch process sequentially to prevent memory overhead or run in parallel
+        for (const text of texts) {
+            const output = await extractor(text, { pooling: 'mean', normalize: true });
+            results.push(Array.from(output.data));
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=TransformersProvider.js.map

package/node_modules/@devbrain/core/dist/index/SQLiteVectorStore.d.ts

@@ -0,0 +1,19 @@
+import { VectorChunk, VectorStore } from './VectorStore.js';
+export declare class SQLiteVectorStore implements VectorStore {
+    private db;
+    private dbPath;
+    constructor(dbPath: string);
+    initialize(): void;
+    private ensureInitialized;
+    upsertChunks(chunks: VectorChunk[]): Promise<void>;
+    deleteChunks(ids: string[]): Promise<void>;
+    getChunksByHash(ids: string[]): Promise<Map<string, string>>;
+    getAllChunksForMemory(memoryId: string): Promise<{
+        id: string;
+        textHash: string;
+    }[]>;
+    search(queryEmbedding: number[]): Promise<VectorChunk[]>;
+    getChunkById(id: string): Promise<VectorChunk | null>;
+    clearAll(): Promise<void>;
+    close(): void;
+}

package/node_modules/@devbrain/core/dist/index/SQLiteVectorStore.js

@@ -0,0 +1,189 @@
+import { DatabaseSync } from 'node:sqlite';
+import path from 'node:path';
+import fs from 'node:fs';
+export class SQLiteVectorStore {
+    db = null;
+    dbPath;
+    constructor(dbPath) {
+        this.dbPath = dbPath;
+    }
+    initialize() {
+        if (this.db)
+            return;
+        const dir = path.dirname(this.dbPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        try {
+            this.db = new DatabaseSync(this.dbPath);
+            // Create table
+            this.db.exec(`
+        CREATE TABLE IF NOT EXISTS memory_vectors (
+          id TEXT PRIMARY KEY,
+          memory_id TEXT NOT NULL,
+          parent_id TEXT,
+          level TEXT NOT NULL,
+          text TEXT NOT NULL,
+          text_hash TEXT NOT NULL,
+          embedding BLOB NOT NULL,
+          metadata TEXT,
+          created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+          updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+        )
+      `);
+            this.db.exec(`
+        CREATE INDEX IF NOT EXISTS idx_memory_vectors_memory_id ON memory_vectors(memory_id)
+      `);
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize SQLite vector database at ${this.dbPath}: ${error.message}`);
+        }
+    }
+    ensureInitialized() {
+        if (!this.db) {
+            this.initialize();
+        }
+    }
+    async upsertChunks(chunks) {
+        this.ensureInitialized();
+        if (chunks.length === 0)
+            return;
+        const insertStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO memory_vectors (
+        id, memory_id, parent_id, level, text, text_hash, embedding, metadata, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+    `);
+        this.db.exec('BEGIN TRANSACTION');
+        try {
+            for (const chunk of chunks) {
+                const floatArray = new Float32Array(chunk.embedding);
+                const buffer = Buffer.from(floatArray.buffer, floatArray.byteOffset, floatArray.byteLength);
+                insertStmt.run(chunk.id, chunk.memoryId, chunk.parentId, chunk.level, chunk.text, chunk.textHash, buffer, chunk.metadata);
+            }
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async deleteChunks(ids) {
+        this.ensureInitialized();
+        if (ids.length === 0)
+            return;
+        const deleteStmt = this.db.prepare(`
+      DELETE FROM memory_vectors WHERE id = ?
+    `);
+        this.db.exec('BEGIN TRANSACTION');
+        try {
+            for (const id of ids) {
+                deleteStmt.run(id);
+            }
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    async getChunksByHash(ids) {
+        this.ensureInitialized();
+        const result = new Map();
+        if (ids.length === 0)
+            return result;
+        const queryStmt = this.db.prepare(`
+      SELECT text_hash FROM memory_vectors WHERE id = ?
+    `);
+        for (const id of ids) {
+            const row = queryStmt.get(id);
+            if (row) {
+                result.set(id, row.text_hash);
+            }
+        }
+        return result;
+    }
+    async getAllChunksForMemory(memoryId) {
+        this.ensureInitialized();
+        const queryStmt = this.db.prepare(`
+      SELECT id, text_hash FROM memory_vectors WHERE memory_id = ?
+    `);
+        const rows = queryStmt.all(memoryId);
+        return rows.map(r => ({ id: r.id, textHash: r.text_hash }));
+    }
+    async search(queryEmbedding) {
+        this.ensureInitialized();
+        const queryStmt = this.db.prepare(`
+      SELECT id, memory_id, parent_id, level, text, text_hash, embedding, metadata FROM memory_vectors
+    `);
+        const rows = queryStmt.all();
+        const results = [];
+        const qLength = queryEmbedding.length;
+        for (const row of rows) {
+            // Use buffer slicing to construct a perfectly aligned Float32Array
+            const buffer = row.embedding;
+            const alignedBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+            const floatArray = new Float32Array(alignedBuffer);
+            let dotProduct = 0;
+            const minLen = Math.min(qLength, floatArray.length);
+            for (let i = 0; i < minLen; i++) {
+                dotProduct += queryEmbedding[i] * floatArray[i];
+            }
+            results.push({
+                id: row.id,
+                memoryId: row.memory_id,
+                parentId: row.parent_id,
+                level: row.level,
+                text: row.text,
+                textHash: row.text_hash,
+                embedding: Array.from(floatArray),
+                metadata: row.metadata,
+                similarity: dotProduct
+            });
+        }
+        // Sort by similarity descending
+        results.sort((a, b) => b.similarity - a.similarity);
+        return results.map(r => {
+            let metaObj = {};
+            try {
+                metaObj = JSON.parse(r.metadata);
+            }
+            catch { }
+            metaObj.similarity = r.similarity;
+            r.metadata = JSON.stringify(metaObj);
+            return r;
+        });
+    }
+    async getChunkById(id) {
+        this.ensureInitialized();
+        const queryStmt = this.db.prepare(`
+      SELECT id, memory_id, parent_id, level, text, text_hash, embedding, metadata FROM memory_vectors WHERE id = ?
+    `);
+        const row = queryStmt.get(id);
+        if (!row)
+            return null;
+        const buffer = row.embedding;
+        const alignedBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        const floatArray = new Float32Array(alignedBuffer);
+        return {
+            id: row.id,
+            memoryId: row.memory_id,
+            parentId: row.parent_id,
+            level: row.level,
+            text: row.text,
+            textHash: row.text_hash,
+            embedding: Array.from(floatArray),
+            metadata: row.metadata
+        };
+    }
+    async clearAll() {
+        this.ensureInitialized();
+        this.db.exec(`DELETE FROM memory_vectors`);
+    }
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+}
+//# sourceMappingURL=SQLiteVectorStore.js.map

package/node_modules/@devbrain/core/dist/index/VectorIndexer.d.ts

@@ -0,0 +1,20 @@
+import { VectorStore } from './VectorStore.js';
+import { EmbeddingProvider } from '../embeddings/EmbeddingProvider.js';
+interface ParsedChunk {
+    id: string;
+    memoryId: string;
+    parentId: string | null;
+    level: 'section' | 'bullet';
+    text: string;
+    textHash: string;
+    metadata: any;
+}
+export declare class VectorIndexer {
+    private readonly vectorStore;
+    private readonly embeddingProvider;
+    constructor(vectorStore: VectorStore, embeddingProvider: EmbeddingProvider);
+    private hashText;
+    parseMarkdown(filePath: string, memoryId: string): ParsedChunk[];
+    indexMemory(filePath: string, memoryId: string): Promise<void>;
+}
+export {};