devbrain-cli 0.1.0 → 0.3.0

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/filesystem/filesystem.service.js

@@ -0,0 +1,87 @@
+import { mkdir, readFile, writeFile, rename, stat } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { FilesystemError } from '@devbrain/shared';
+/**
+ * Service for safe filesystem operations.
+ */
+export class FilesystemService {
+    /**
+     * Check if a path exists.
+     */
+    async exists(path) {
+        try {
+            await stat(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Reads contents of a file as a string.
+     */
+    async read(path) {
+        try {
+            return await readFile(path, 'utf8');
+        }
+        catch (error) {
+            throw new FilesystemError(`Failed to read file at ${path}`, error.message || 'File might not exist or is not readable', 'Verify the path is correct and has appropriate read permissions.');
+        }
+    }
+    /**
+     * Writes content to a file, creating directories recursively.
+     */
+    async write(path, content) {
+        try {
+            const dir = dirname(path);
+            await mkdir(dir, { recursive: true });
+            await writeFile(path, content, 'utf8');
+        }
+        catch (error) {
+            throw new FilesystemError(`Failed to write file to ${path}`, error.message || 'Directory could not be created or file is locked', 'Check disk space, directory write permissions, and that target file is not locked.');
+        }
+    }
+    /**
+     * Atomically writes file content by writing to a temporary file then renaming.
+     */
+    async writeAtomic(path, content) {
+        const tempPath = `${path}.tmp-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        try {
+            await this.write(tempPath, content);
+            await rename(tempPath, path);
+        }
+        catch (error) {
+            // Clean up temp path if it exists
+            try {
+                if (await this.exists(tempPath)) {
+                    const { unlink } = await import('node:fs/promises');
+                    await unlink(tempPath);
+                }
+            }
+            catch {
+                // Ignore cleanup error
+            }
+            throw new FilesystemError(`Failed to atomically write file to ${path}`, error.message || 'Atomic rename failed', 'Ensure the destination folder is writable and in the same filesystem drive.');
+        }
+    }
+    /**
+     * Reads and parses a JSON file.
+     */
+    async readJson(path) {
+        const raw = await this.read(path);
+        try {
+            return JSON.parse(raw);
+        }
+        catch (error) {
+            throw new FilesystemError(`Failed to parse JSON file at ${path}`, error.message || 'Invalid JSON format', 'Correct the JSON syntax or reconstruct the file configuration.');
+        }
+    }
+    /**
+     * Writes JSON data to a file (optionally atomically).
+     */
+    async writeJson(path, data, indent = 2) {
+        const content = JSON.stringify(data, null, indent) + '\n';
+        await this.writeAtomic(path, content);
+    }
+}
+//# sourceMappingURL=filesystem.service.js.map

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/git/git.service.d.ts

@@ -0,0 +1,42 @@
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export declare class GitService {
+    private readonly cwd;
+    private readonly fsService;
+    private readonly git;
+    constructor(cwd: string, fsService?: FilesystemService);
+    /**
+     * Check if the directory is a valid git repository.
+     */
+    isGitRepository(): Promise<boolean>;
+    /**
+     * Retrieve the current HEAD commit hash.
+     */
+    getCurrentCommitHash(): Promise<string | null>;
+    /**
+     * Get the list of modified/added/deleted files between two commits.
+     */
+    getChangedFiles(sinceHash: string, toHash?: string): Promise<{
+        modified: string[];
+        deleted: string[];
+        renamed: {
+            from: string;
+            to: string;
+        }[];
+    }>;
+    /**
+     * Get the commit message of the specified commit hash.
+     */
+    getCommitMessage(hash: string): Promise<string>;
+    /**
+     * Install post-commit Git hook.
+     */
+    installHook(hookName?: string): Promise<void>;
+    /**
+     * Remove post-commit Git hook.
+     */
+    removeHook(hookName?: string): Promise<void>;
+    /**
+     * Check if hook is installed and managed by DevBrain.
+     */
+    isHookInstalled(hookName?: string): Promise<boolean>;
+}

package/dist/temp-prefix/node_modules/devbrain-cli/node_modules/@devbrain/core/dist/git/git.service.js

@@ -0,0 +1,192 @@
+import { join } from 'node:path';
+import { chmod } from 'node:fs/promises';
+import { simpleGit } from 'simple-git';
+import { FilesystemService } from '../filesystem/filesystem.service.js';
+export class GitService {
+    cwd;
+    fsService;
+    git;
+    constructor(cwd, fsService = new FilesystemService()) {
+        this.cwd = cwd;
+        this.fsService = fsService;
+        this.git = simpleGit({ baseDir: cwd });
+    }
+    /**
+     * Check if the directory is a valid git repository.
+     */
+    async isGitRepository() {
+        try {
+            return await this.git.checkIsRepo();
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Retrieve the current HEAD commit hash.
+     */
+    async getCurrentCommitHash() {
+        try {
+            const hash = await this.git.revparse(['HEAD']);
+            return hash.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get the list of modified/added/deleted files between two commits.
+     */
+    async getChangedFiles(sinceHash, toHash = 'HEAD') {
+        try {
+            // Get raw diff summary
+            const diffSummary = await this.git.diffSummary([sinceHash, toHash]);
+            const modified = [];
+            const deleted = [];
+            const renamed = [];
+            for (const file of diffSummary.files) {
+                // simple-git's diffSummary indicates file operations
+                if (file.file.includes(' => ')) {
+                    // File rename format: path/to/{old => new}/file or old => new
+                    const renameMatch = file.file.match(/^(.*?)\{(.*?) => (.*?)\}(.*)$/) ||
+                        file.file.match(/^(.*?) => (.*)$/);
+                    if (renameMatch) {
+                        let from = '';
+                        let to = '';
+                        if (renameMatch.length === 5) {
+                            const prefix = renameMatch[1];
+                            const oldPart = renameMatch[2];
+                            const newPart = renameMatch[3];
+                            const suffix = renameMatch[4];
+                            from = `${prefix}${oldPart}${suffix}`.replace('//', '/');
+                            to = `${prefix}${newPart}${suffix}`.replace('//', '/');
+                        }
+                        else {
+                            from = renameMatch[1].trim();
+                            to = renameMatch[2].trim();
+                        }
+                        renamed.push({ from, to });
+                    }
+                    else {
+                        // Fallback if regex mismatch
+                        modified.push(file.file);
+                    }
+                }
+                else {
+                    // Check if deleted
+                    // In git diff-tree or summary, we check if changes are deletions
+                    // diffSummary includes changes. We can verify if the file exists locally to confirm status.
+                    const exists = await this.fsService.exists(join(this.cwd, file.file));
+                    if (!exists) {
+                        deleted.push(file.file);
+                    }
+                    else {
+                        modified.push(file.file);
+                    }
+                }
+            }
+            return { modified, deleted, renamed };
+        }
+        catch {
+            return { modified: [], deleted: [], renamed: [] };
+        }
+    }
+    /**
+     * Get the commit message of the specified commit hash.
+     */
+    async getCommitMessage(hash) {
+        try {
+            const message = await this.git.show(['-s', '--format=%B', hash]);
+            return message.trim();
+        }
+        catch {
+            return 'No commit message';
+        }
+    }
+    /**
+     * Install post-commit Git hook.
+     */
+    async installHook(hookName = 'post-commit') {
+        const hooksDir = join(this.cwd, '.git', 'hooks');
+        if (!(await this.fsService.exists(hooksDir))) {
+            throw new Error('Not a Git repository or hooks directory is missing.');
+        }
+        const hookPath = join(hooksDir, hookName);
+        // Construct robust POSIX shell script template that executes async
+        const hookContent = [
+            '#!/bin/sh',
+            '# DevBrain Autonomous Git Memory Engine Hook',
+            '',
+            '# Set base path',
+            'PROJECT_DIR="$(pwd)"',
+            'LOG_FILE="$PROJECT_DIR/.devbrain/logs/git-hook.log"',
+            'LOCK_FILE="$PROJECT_DIR/.devbrain/.lock"',
+            '',
+            'mkdir -p "$PROJECT_DIR/.devbrain/logs"',
+            '',
+            '# Run in background to not block commit',
+            '(',
+            '  # Check lock file',
+            '  if [ -f "$LOCK_FILE" ]; then',
+            '    echo "$(date): Skip execution: Another DevBrain process is running." >> "$LOG_FILE"',
+            '    exit 0',
+            '  fi',
+            '',
+            '  echo "$(date): Triggering incremental learn..." >> "$LOG_FILE"',
+            '',
+            '  # Resolve and run devbrain',
+            '  if [ -f "$PROJECT_DIR/node_modules/.bin/devbrain" ]; then',
+            '    "$PROJECT_DIR/node_modules/.bin/devbrain" learn --silent >> "$LOG_FILE" 2>&1',
+            '  elif command -v devbrain >/dev/null 2>&1; then',
+            '    devbrain learn --silent >> "$LOG_FILE" 2>&1',
+            '  else',
+            '    npx --no-install devbrain learn --silent >> "$LOG_FILE" 2>&1',
+            '  fi',
+            '  ',
+            '  # Log result status code',
+            '  STATUS=$?',
+            '  if [ $STATUS -ne 0 ]; then',
+            '    echo "$(date): Error: DevBrain execution failed with code $STATUS" >> "$LOG_FILE"',
+            '  else',
+            '    echo "$(date): DevBrain learning updated successfully." >> "$LOG_FILE"',
+            '  fi',
+            ') >/dev/null 2>&1 &',
+            '',
+            'exit 0',
+        ].join('\n') + '\n';
+        await this.fsService.write(hookPath, hookContent);
+        // Make script executable
+        try {
+            await chmod(hookPath, 0o755);
+        }
+        catch {
+            // Mode modification might fail on Windows, fallback silently
+        }
+    }
+    /**
+     * Remove post-commit Git hook.
+     */
+    async removeHook(hookName = 'post-commit') {
+        const hookPath = join(this.cwd, '.git', 'hooks', hookName);
+        if (await this.fsService.exists(hookPath)) {
+            const content = await this.fsService.read(hookPath);
+            // Only delete if it's managed by DevBrain
+            if (content.includes('DevBrain Autonomous')) {
+                const { unlink } = await import('node:fs/promises');
+                await unlink(hookPath);
+            }
+        }
+    }
+    /**
+     * Check if hook is installed and managed by DevBrain.
+     */
+    async isHookInstalled(hookName = 'post-commit') {
+        const hookPath = join(this.cwd, '.git', 'hooks', hookName);
+        if (await this.fsService.exists(hookPath)) {
+            const content = await this.fsService.read(hookPath);
+            return content.includes('DevBrain Autonomous');
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=git.service.js.map

package/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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/dist/temp-prefix/node_modules/devbrain-cli/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 {};