codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/storage/sqlite-memory-repository.js

@@ -1,229 +0,0 @@
-/**
- * Infrastructure: SQLiteMemoryRepository
- * Implements IMemoryRepository using SQLite
- */
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import initSqlJs from 'sql.js';
-import { randomUUID } from 'crypto';
-function getDbPath() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '../../..');
-    if (existsSync(join(agentDir, 'package.json'))) {
-        return join(agentDir, 'data', 'memory_stream.sqlite');
-    }
-    return join(process.cwd(), 'agent', 'data', 'memory_stream.sqlite');
-}
-export class SQLiteMemoryRepository {
-    dbPath;
-    db = null;
-    constructor() {
-        this.dbPath = getDbPath();
-    }
-    async getDb() {
-        if (this.db)
-            return this.db;
-        const SQL = await initSqlJs();
-        const dbDir = dirname(this.dbPath);
-        if (!existsSync(dbDir)) {
-            mkdirSync(dbDir, { recursive: true });
-        }
-        if (existsSync(this.dbPath)) {
-            const buffer = readFileSync(this.dbPath);
-            this.db = new SQL.Database(buffer);
-        }
-        else {
-            this.db = new SQL.Database();
-        }
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS memory_stream (
-        id TEXT PRIMARY KEY,
-        type TEXT NOT NULL,
-        description TEXT NOT NULL,
-        embedding TEXT NOT NULL,
-        timestamp INTEGER NOT NULL,
-        importance INTEGER NOT NULL,
-        lastAccessed INTEGER NOT NULL,
-        metadata TEXT
-      )
-    `);
-        this.db.run(`
-      CREATE INDEX IF NOT EXISTS idx_timestamp ON memory_stream(timestamp)
-    `);
-        this.db.run(`
-      CREATE INDEX IF NOT EXISTS idx_type ON memory_stream(type)
-    `);
-        // Add index on metadata for codebase filtering (metadata stored as JSON)
-        // We'll query using JSON functions if supported, or parse in memory
-        // For now, we can filter in memory after retrieval
-        return this.db;
-    }
-    async store(memory) {
-        const db = await this.getDb();
-        const id = memory.id || randomUUID();
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO memory_stream 
-      (id, type, description, embedding, timestamp, importance, lastAccessed, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run([
-            id,
-            memory.type,
-            memory.description,
-            JSON.stringify(memory.embedding),
-            memory.timestamp.getTime(),
-            memory.importance,
-            memory.lastAccessed.getTime(),
-            JSON.stringify(memory.metadata || {}),
-        ]);
-        stmt.free();
-        this.saveDb();
-    }
-    async retrieve(query, limit) {
-        // This will be enhanced with embedding-based search
-        // For now, return recent memories
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM memory_stream 
-      ORDER BY timestamp DESC 
-      LIMIT ?
-    `);
-        stmt.bind([limit]);
-        const memories = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            memories.push({
-                id: row.id,
-                type: row.type,
-                description: row.description,
-                embedding: JSON.parse(row.embedding),
-                timestamp: new Date(row.timestamp),
-                importance: row.importance,
-                lastAccessed: new Date(row.lastAccessed),
-                metadata: JSON.parse(row.metadata || '{}'),
-            });
-        }
-        stmt.free();
-        return memories;
-    }
-    async getById(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT * FROM memory_stream WHERE id = ?');
-        stmt.bind([id]);
-        if (!stmt.step()) {
-            stmt.free();
-            return null;
-        }
-        const row = stmt.getAsObject();
-        stmt.free();
-        return {
-            id: row.id,
-            type: row.type,
-            description: row.description,
-            embedding: JSON.parse(row.embedding),
-            timestamp: new Date(row.timestamp),
-            importance: row.importance,
-            lastAccessed: new Date(row.lastAccessed),
-            metadata: JSON.parse(row.metadata || '{}'),
-        };
-    }
-    async update(memory) {
-        await this.store(memory);
-    }
-    async clear() {
-        const db = await this.getDb();
-        db.run('DELETE FROM memory_stream');
-        this.saveDb();
-    }
-    /**
-     * Find recent memories (ordered by timestamp DESC)
-     */
-    async findRecent(limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM memory_stream 
-      ORDER BY timestamp DESC 
-      LIMIT ?
-    `);
-        stmt.bind([limit]);
-        const memories = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            memories.push({
-                id: row.id,
-                type: row.type,
-                description: row.description,
-                embedding: JSON.parse(row.embedding),
-                timestamp: new Date(row.timestamp),
-                importance: row.importance,
-                lastAccessed: new Date(row.lastAccessed),
-                metadata: JSON.parse(row.metadata || '{}'),
-            });
-        }
-        stmt.free();
-        return memories;
-    }
-    /**
-     * Retrieve all memories (for MemoryRetriever to score)
-     */
-    async getAll() {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT * FROM memory_stream');
-        const memories = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            memories.push({
-                id: row.id,
-                type: row.type,
-                description: row.description,
-                embedding: JSON.parse(row.embedding),
-                timestamp: new Date(row.timestamp),
-                importance: row.importance,
-                lastAccessed: new Date(row.lastAccessed),
-                metadata: JSON.parse(row.metadata || '{}'),
-            });
-        }
-        stmt.free();
-        return memories;
-    }
-    /**
-     * Find recent memories for a specific codebase
-     */
-    async findRecentByCodebase(codebaseId, limit) {
-        const allRecent = await this.findRecent(limit * 2); // Get more to filter
-        const filtered = allRecent.filter((memory) => {
-            return memory.metadata?.codebaseId === codebaseId;
-        });
-        return filtered.slice(0, limit);
-    }
-    /**
-     * Retrieve memories filtered by codebase
-     * Note: This filters after retrieval since we store codebaseId in metadata
-     */
-    async retrieveByCodebase(query, codebaseId, limit) {
-        const allMemories = await this.retrieve(query, limit * 2); // Get more to filter
-        const filtered = allMemories.filter((memory) => {
-            return memory.metadata?.codebaseId === codebaseId;
-        });
-        return filtered.slice(0, limit);
-    }
-    /**
-     * Get all memories for a specific codebase
-     */
-    async getAllByCodebase(codebaseId) {
-        const allMemories = await this.getAll();
-        return allMemories.filter((memory) => {
-            return memory.metadata?.codebaseId === codebaseId;
-        });
-    }
-    saveDb() {
-        if (!this.db)
-            return;
-        const data = this.db.export();
-        const buffer = Buffer.from(data);
-        writeFileSync(this.dbPath, buffer);
-    }
-}
-//# sourceMappingURL=sqlite-memory-repository.js.map

package/dist/infrastructure/storage/sqlite-pattern-repository.js

@@ -1,249 +0,0 @@
-/**
- * Infrastructure: SQLitePatternRepository
- * Implements IPatternRepository using SQLite
- */
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import initSqlJs from 'sql.js';
-import { randomUUID } from 'crypto';
-function getDbPath() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '../../..');
-    if (existsSync(join(agentDir, 'package.json'))) {
-        return join(agentDir, 'data', 'patterns.sqlite');
-    }
-    return join(process.cwd(), 'agent', 'data', 'patterns.sqlite');
-}
-export class SQLitePatternRepository {
-    dbPath;
-    db = null;
-    constructor() {
-        this.dbPath = getDbPath();
-    }
-    async getDb() {
-        if (this.db)
-            return this.db;
-        const SQL = await initSqlJs();
-        const dbDir = dirname(this.dbPath);
-        if (!existsSync(dbDir)) {
-            mkdirSync(dbDir, { recursive: true });
-        }
-        if (existsSync(this.dbPath)) {
-            const buffer = readFileSync(this.dbPath);
-            this.db = new SQL.Database(buffer);
-        }
-        else {
-            this.db = new SQL.Database();
-        }
-        // Create patterns table
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS patterns (
-        id TEXT PRIMARY KEY,
-        codebaseId TEXT NOT NULL,
-        type TEXT NOT NULL,
-        name TEXT NOT NULL,
-        description TEXT NOT NULL,
-        codeExample TEXT,
-        filepath TEXT,
-        lineStart INTEGER,
-        lineEnd INTEGER,
-        metadata TEXT,
-        createdAt INTEGER NOT NULL,
-        lastUsed INTEGER,
-        usageCount INTEGER NOT NULL DEFAULT 0
-      )
-    `);
-        // Create indexes for efficient queries
-        this.db.run(`
-      CREATE INDEX IF NOT EXISTS idx_codebase ON patterns(codebaseId)
-    `);
-        this.db.run(`
-      CREATE INDEX IF NOT EXISTS idx_type ON patterns(codebaseId, type)
-    `);
-        this.db.run(`
-      CREATE INDEX IF NOT EXISTS idx_usage ON patterns(codebaseId, usageCount DESC)
-    `);
-        this.db.run(`
-      CREATE INDEX IF NOT EXISTS idx_created ON patterns(codebaseId, createdAt DESC)
-    `);
-        return this.db;
-    }
-    async store(pattern) {
-        const db = await this.getDb();
-        // Ensure pattern has an ID
-        if (!pattern.id) {
-            pattern.id = randomUUID();
-        }
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO patterns 
-      (id, codebaseId, type, name, description, codeExample, filepath, 
-       lineStart, lineEnd, metadata, createdAt, lastUsed, usageCount)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        // Ensure all values are properly typed (no undefined)
-        stmt.run([
-            pattern.id,
-            pattern.codebaseId,
-            pattern.type,
-            pattern.name,
-            pattern.description,
-            pattern.codeExample ?? null,
-            pattern.filepath ?? null,
-            pattern.lineNumbers?.start ?? null,
-            pattern.lineNumbers?.end ?? null,
-            JSON.stringify(pattern.metadata || {}),
-            pattern.createdAt.getTime(),
-            pattern.lastUsed ? pattern.lastUsed.getTime() : null,
-            pattern.usageCount ?? 0,
-        ]);
-        stmt.free();
-        this.saveDb();
-    }
-    async getById(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT * FROM patterns WHERE id = ?');
-        stmt.bind([id]);
-        if (!stmt.step()) {
-            stmt.free();
-            return null;
-        }
-        const row = stmt.getAsObject();
-        stmt.free();
-        return this.rowToPattern(row);
-    }
-    async findByCodebase(codebaseId) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM patterns 
-      WHERE codebaseId = ? 
-      ORDER BY createdAt DESC
-    `);
-        stmt.bind([codebaseId]);
-        const patterns = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            patterns.push(this.rowToPattern(row));
-        }
-        stmt.free();
-        return patterns;
-    }
-    async findByType(codebaseId, type) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM patterns 
-      WHERE codebaseId = ? AND type = ?
-      ORDER BY createdAt DESC
-    `);
-        stmt.bind([codebaseId, type]);
-        const patterns = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            patterns.push(this.rowToPattern(row));
-        }
-        stmt.free();
-        return patterns;
-    }
-    async search(codebaseId, query, limit = 10) {
-        const db = await this.getDb();
-        const searchTerm = `%${query.toLowerCase()}%`;
-        const stmt = db.prepare(`
-      SELECT * FROM patterns 
-      WHERE codebaseId = ? 
-      AND (LOWER(name) LIKE ? OR LOWER(description) LIKE ?)
-      ORDER BY usageCount DESC, createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, searchTerm, searchTerm, limit]);
-        const patterns = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            patterns.push(this.rowToPattern(row));
-        }
-        stmt.free();
-        return patterns;
-    }
-    async update(pattern) {
-        await this.store(pattern);
-    }
-    async delete(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('DELETE FROM patterns WHERE id = ?');
-        stmt.bind([id]);
-        stmt.step();
-        stmt.free();
-        this.saveDb();
-    }
-    async getMostUsed(codebaseId, limit = 10) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM patterns 
-      WHERE codebaseId = ?
-      ORDER BY usageCount DESC, createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, limit]);
-        const patterns = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            patterns.push(this.rowToPattern(row));
-        }
-        stmt.free();
-        return patterns;
-    }
-    async getRecent(codebaseId, limit = 10) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM patterns 
-      WHERE codebaseId = ?
-      ORDER BY createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, limit]);
-        const patterns = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            patterns.push(this.rowToPattern(row));
-        }
-        stmt.free();
-        return patterns;
-    }
-    async getByTags(codebaseId, tags) {
-        // SQLite doesn't have great JSON support, so we'll filter in memory
-        // For production, consider storing tags in a separate table
-        const allPatterns = await this.findByCodebase(codebaseId);
-        return allPatterns.filter(pattern => {
-            const patternTags = pattern.metadata?.tags || [];
-            return tags.some(tag => patternTags.includes(tag));
-        });
-    }
-    rowToPattern(row) {
-        const metadata = JSON.parse(row.metadata || '{}');
-        return {
-            id: row.id,
-            codebaseId: row.codebaseId,
-            type: row.type,
-            name: row.name,
-            description: row.description,
-            codeExample: row.codeExample || undefined,
-            filepath: row.filepath || undefined,
-            lineNumbers: row.lineStart && row.lineEnd ? {
-                start: row.lineStart,
-                end: row.lineEnd,
-            } : undefined,
-            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
-            createdAt: new Date(row.createdAt),
-            lastUsed: row.lastUsed ? new Date(row.lastUsed) : undefined,
-            usageCount: row.usageCount || 0,
-        };
-    }
-    saveDb() {
-        if (!this.db)
-            return;
-        const data = this.db.export();
-        const buffer = Buffer.from(data);
-        writeFileSync(this.dbPath, buffer);
-    }
-}
-//# sourceMappingURL=sqlite-pattern-repository.js.map

package/dist/infrastructure/storage/task-helpers.js

@@ -1,197 +0,0 @@
-/**
- * Infrastructure: Task Helpers
- * Helper functions for creating and updating tasks (non-breaking)
- *
- * Phase 1: v0.5.0-alpha
- * See: .internal/ARCHITECTURE.md (internal docs)
- */
-import { getTaskRepository } from './task-repository.js';
-import { TaskMode, TaskStatus, RiskTier, ReviewStatus } from '../../domain/entities/task.js';
-import { getCurrentEnvironmentMode } from '../../domain/services/environment-mode-manager.js';
-import { detectRiskTier, detectRiskTierFromPlan } from '../../domain/services/risk-tier-detector.js';
-import { randomUUID } from 'crypto';
-/**
- * Create task for plan command
- * Non-breaking: silent failure, doesn't affect user workflow
- */
-export async function createPlanTask(options) {
-    const { goal, plan, codebaseInfo, runId } = options;
-    try {
-        const taskRepo = getTaskRepository();
-        const environment = getCurrentEnvironmentMode();
-        const riskTier = detectRiskTierFromPlan(plan);
-        const taskId = `task-${randomUUID()}`;
-        await taskRepo.create({
-            id: taskId,
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
-            codebaseId: codebaseInfo?.codebaseId || codebaseInfo?.rootPath || process.cwd(),
-            cwd: process.cwd(),
-            mode: TaskMode.PLAN,
-            goal,
-            command: 'plan',
-            status: TaskStatus.PLANNED,
-            riskTier,
-            environment,
-            planId: plan.id,
-            plan: plan, // Store serialized plan
-            traceSummaryId: runId,
-        });
-        return taskId;
-    }
-    catch {
-        // Silent failure - task creation is optional
-        return null;
-    }
-}
-/**
- * Create task for suggest command
- * Non-breaking: silent failure, doesn't affect user workflow
- * Suggest tasks are ephemeral (T1, always low risk)
- */
-export async function createSuggestTask(options) {
-    const { query, filePath, codebaseInfo, runId } = options;
-    try {
-        const taskRepo = getTaskRepository();
-        const environment = getCurrentEnvironmentMode();
-        // Suggest mode is always T1 (low risk, read-only)
-        const taskId = `task-${randomUUID()}`;
-        const fullQuery = filePath ? `${query} (file: ${filePath})` : query;
-        await taskRepo.create({
-            id: taskId,
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
-            codebaseId: codebaseInfo?.codebaseId || codebaseInfo?.rootPath || process.cwd(),
-            cwd: process.cwd(),
-            mode: TaskMode.SUGGEST,
-            goal: fullQuery,
-            command: 'suggest',
-            status: TaskStatus.CREATED,
-            riskTier: RiskTier.T1, // Always low risk for read-only operations
-            environment,
-            traceSummaryId: runId,
-        });
-        return taskId;
-    }
-    catch {
-        // Silent failure - task creation is optional
-        return null;
-    }
-}
-/**
- * Create task for fix/run command
- * Non-breaking: silent failure, doesn't affect user workflow
- */
-export async function createRunTask(options) {
-    const { goal, filePath, codebaseInfo, runId, files = [] } = options;
-    try {
-        const taskRepo = getTaskRepository();
-        const environment = getCurrentEnvironmentMode();
-        const riskTier = detectRiskTier(files);
-        const taskId = `task-${randomUUID()}`;
-        const fullGoal = filePath ? `${goal} (file: ${filePath})` : goal;
-        await taskRepo.create({
-            id: taskId,
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
-            codebaseId: codebaseInfo?.codebaseId || codebaseInfo?.rootPath || process.cwd(),
-            cwd: process.cwd(),
-            mode: TaskMode.RUN,
-            goal: fullGoal,
-            command: filePath ? 'fix' : 'run',
-            status: TaskStatus.CREATED,
-            riskTier,
-            environment,
-            filesChanged: files.length > 0 ? files : undefined,
-            traceSummaryId: runId,
-        });
-        return taskId;
-    }
-    catch {
-        // Silent failure - task creation is optional
-        return null;
-    }
-}
-/**
- * Update task status
- * Non-breaking: silent failure
- */
-export async function updateTaskStatus(taskId, status, updates) {
-    if (!taskId) {
-        return;
-    }
-    try {
-        const taskRepo = getTaskRepository();
-        const existing = await taskRepo.getById(taskId);
-        if (!existing) {
-            return;
-        }
-        await taskRepo.update({
-            ...existing,
-            ...updates,
-            status,
-            updatedAt: Date.now(),
-        });
-    }
-    catch {
-        // Silent failure
-    }
-}
-/**
- * Update task with execution results
- * Non-breaking: silent failure
- */
-export async function updateTaskWithResults(taskId, results) {
-    if (!taskId) {
-        return;
-    }
-    try {
-        const taskRepo = getTaskRepository();
-        const existing = await taskRepo.getById(taskId);
-        if (!existing) {
-            return;
-        }
-        await taskRepo.update({
-            ...existing,
-            ...results,
-            updatedAt: Date.now(),
-        });
-    }
-    catch {
-        // Silent failure
-    }
-}
-/**
- * Update task review status
- * Non-breaking: silent failure
- */
-export async function updateTaskReview(taskId, reviewStatus, reviewedBy, comments) {
-    if (!taskId) {
-        return;
-    }
-    try {
-        const taskRepo = getTaskRepository();
-        const existing = await taskRepo.getById(taskId);
-        if (!existing) {
-            return;
-        }
-        const newStatus = reviewStatus === ReviewStatus.APPROVED
-            ? TaskStatus.APPROVED
-            : reviewStatus === ReviewStatus.REJECTED
-                ? TaskStatus.REJECTED
-                : existing.status;
-        await taskRepo.update({
-            ...existing,
-            reviewStatus,
-            reviewedAt: Date.now(),
-            reviewedBy,
-            reviewComments: comments,
-            status: newStatus,
-            updatedAt: Date.now(),
-        });
-    }
-    catch {
-        // Silent failure
-    }
-}
-//# sourceMappingURL=task-helpers.js.map