codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/security/sandbox-executor.js

@@ -1,64 +0,0 @@
-/**
- * Infrastructure: Sandbox Executor
- * Main interface for secure code execution
- * Routes to appropriate sandbox implementation (Docker/WASM)
- */
-import { DockerSandbox } from './docker-sandbox.js';
-export class SandboxExecutor {
-    dockerSandbox;
-    useDocker = true; // Default to Docker
-    constructor() {
-        this.dockerSandbox = new DockerSandbox();
-        this.initialize();
-    }
-    /**
-     * Initialize sandbox executor
-     * Check availability of Docker/WASM
-     */
-    async initialize() {
-        const dockerAvailable = await this.dockerSandbox.isAvailable();
-        if (!dockerAvailable) {
-            console.warn('⚠️  Docker not available. Sandbox execution will be limited.');
-            this.useDocker = false;
-        }
-    }
-    /**
-     * Execute code in secure sandbox
-     */
-    async execute(request) {
-        if (!this.useDocker) {
-            // Fallback: Return error if Docker not available
-            return {
-                success: false,
-                output: '',
-                error: 'Docker sandbox not available. Please install Docker to enable secure code execution.',
-                exitCode: 1,
-                duration: 0,
-            };
-        }
-        // Route to Docker sandbox
-        return await this.dockerSandbox.execute(request.code, request.language, request.options);
-    }
-    /**
-     * Execute bash command in sandbox
-     */
-    async executeBash(command, options) {
-        if (!this.useDocker) {
-            return {
-                success: false,
-                output: '',
-                error: 'Docker sandbox not available.',
-                exitCode: 1,
-                duration: 0,
-            };
-        }
-        return await this.dockerSandbox.executeBash(command, options);
-    }
-    /**
-     * Check if sandbox is available
-     */
-    async isAvailable() {
-        return await this.dockerSandbox.isAvailable();
-    }
-}
-//# sourceMappingURL=sandbox-executor.js.map

package/dist/infrastructure/serialization/toon-serializer.js

@@ -1,119 +0,0 @@
-/**
- * TOON (Token-Oriented Object Notation) Serializer
- *
- * Phase 1: Code Context Serialization for v1.0.0 MVP
- *
- * Benefits:
- * - 30-60% token reduction compared to JSON
- * - Better LLM parsing accuracy
- * - Self-documenting structure
- *
- * Feature Flag: CODEHERE_USE_TOON (default: false for v1.0.0)
- */
-let toonLib = null;
-/**
- * Lazy load TOON library (only if feature flag is enabled)
- */
-async function getToonLib() {
-    if (toonLib === null) {
-        try {
-            // Dynamic import for ES modules - use eval to avoid TypeScript compile-time error when package isn't installed
-            // This allows the code to compile even if @toon-format/toon is not installed
-            const toonModulePath = '@toon-format/toon';
-            // eslint-disable-next-line @typescript-eslint/no-implied-eval
-            const toonModule = await import(/* @ts-ignore */ toonModulePath);
-            toonLib = toonModule;
-        }
-        catch (error) {
-            // TOON library not installed or feature disabled
-            return null;
-        }
-    }
-    return toonLib;
-}
-/**
- * Check if TOON is enabled via feature flag
- */
-function isToonEnabled() {
-    return process.env.CODEHERE_USE_TOON === 'true' || process.env.CODEHERE_USE_TOON === '1';
-}
-/**
- * Serialize code chunks to TOON format
- *
- * TOON format for code chunks:
- * chunks[N]{filepath,content,score,lineStart,lineEnd}:
- *   src/auth.ts,function authenticate() {...},0.95,10,60
- *   src/utils.ts,export function helper() {...},0.87,5,35
- *
- * @param chunks Code chunks to serialize
- * @returns TOON-formatted string, or null if TOON is disabled or library unavailable
- */
-export async function serializeCodeChunksToToon(chunks) {
-    if (!isToonEnabled() || chunks.length === 0) {
-        return null;
-    }
-    const toon = await getToonLib();
-    if (!toon) {
-        return null;
-    }
-    try {
-        // Convert code chunks to array of objects for TOON encoding
-        const chunksData = chunks.map(chunk => ({
-            filepath: chunk.filepath,
-            content: chunk.content,
-            score: chunk.score || 1.0,
-            lineStart: chunk.lineStart || 0,
-            lineEnd: chunk.lineEnd || 0,
-        }));
-        // Encode to TOON format
-        // TOON library exports: { encode, decode } or default export
-        const toonData = { chunks: chunksData };
-        const encodeFn = toon.encode || toon.default?.encode || (typeof toon === 'function' ? toon : null);
-        if (!encodeFn || typeof encodeFn !== 'function') {
-            throw new Error('TOON encode function not found in module');
-        }
-        const toonString = encodeFn(toonData, { delimiter: '\t' });
-        return toonString;
-    }
-    catch (error) {
-        // If TOON encoding fails, return null to fall back to JSON
-        console.warn('[TOON] Encoding failed, falling back to JSON:', error instanceof Error ? error.message : String(error));
-        return null;
-    }
-}
-/**
- * Serialize code chunks to traditional format (fallback)
- * Used when TOON is disabled or unavailable
- *
- * @param chunks Code chunks to serialize
- * @returns Traditional formatted string
- */
-export function serializeCodeChunksToTraditional(chunks) {
-    return chunks
-        .map((chunk, idx) => `[Chunk ${idx + 1} from ${chunk.filepath}]\n${chunk.content}`)
-        .join('\n\n---\n\n');
-}
-/**
- * Serialize code chunks (TOON if enabled, traditional otherwise)
- *
- * @param chunks Code chunks to serialize
- * @returns Formatted string (TOON or traditional)
- */
-export async function serializeCodeChunks(chunks) {
-    const toonResult = await serializeCodeChunksToToon(chunks);
-    if (toonResult !== null) {
-        return toonResult;
-    }
-    return serializeCodeChunksToTraditional(chunks);
-}
-/**
- * Check if TOON is available and enabled
- */
-export async function isToonAvailable() {
-    if (!isToonEnabled()) {
-        return false;
-    }
-    const lib = await getToonLib();
-    return lib !== null;
-}
-//# sourceMappingURL=toon-serializer.js.map

package/dist/infrastructure/storage/memory-stream-service.js

@@ -1,204 +0,0 @@
-/**
- * Infrastructure: MemoryStreamService
- * Manages episodic memory with 3-factor scoring
- */
-import { MemoryRetriever } from '../../domain/services/memory-retriever.js';
-import { getEmbeddingCache } from '../cache/embedding-cache.js';
-export class MemoryStreamService {
-    repository;
-    retriever;
-    aiService;
-    embeddingCache = getEmbeddingCache();
-    constructor(repository, aiService) {
-        this.repository = repository;
-        this.aiService = aiService;
-        this.retriever = new MemoryRetriever(); // Pure domain service, no dependencies
-    }
-    /**
-     * Store observation
-     */
-    async recordObservation(description, metadata, codebaseId, codebasePath) {
-        const embedding = await this.aiService.embed(description);
-        if (Array.isArray(embedding[0])) {
-            throw new Error('Expected single embedding');
-        }
-        const memory = {
-            type: 'observation',
-            description,
-            embedding: embedding,
-            timestamp: new Date(),
-            importance: this.calculateImportance(description),
-            lastAccessed: new Date(),
-            metadata: {
-                ...metadata,
-                ...(codebaseId && { codebaseId }),
-                ...(codebasePath && { codebasePath }),
-            },
-        };
-        await this.repository.store(memory);
-    }
-    /**
-     * Store reflection
-     */
-    async recordReflection(description, trajectory, reward, errors, codebaseId, codebasePath) {
-        const embedding = await this.aiService.embed(description);
-        if (Array.isArray(embedding[0])) {
-            throw new Error('Expected single embedding');
-        }
-        const memory = {
-            type: 'reflection',
-            description,
-            embedding: embedding,
-            timestamp: new Date(),
-            importance: 8, // Reflections are high importance
-            lastAccessed: new Date(),
-            metadata: {
-                trajectory,
-                reward,
-                errors,
-                ...(codebaseId && { codebaseId }),
-                ...(codebasePath && { codebasePath }),
-            },
-        };
-        await this.repository.store(memory);
-    }
-    /**
-     * Store plan
-     */
-    async recordPlan(description, plan, codebaseId, codebasePath) {
-        const embedding = await this.aiService.embed(description);
-        if (Array.isArray(embedding[0])) {
-            throw new Error('Expected single embedding');
-        }
-        const memory = {
-            type: 'plan',
-            description,
-            embedding: embedding,
-            timestamp: new Date(),
-            importance: 7,
-            lastAccessed: new Date(),
-            metadata: {
-                plan,
-                ...(codebaseId && { codebaseId }),
-                ...(codebasePath && { codebasePath }),
-            },
-        };
-        await this.repository.store(memory);
-    }
-    /**
-     * Retrieve relevant memories with optional reranking
-     * Uses two-stage retrieval: initial recall → rerank precision
-     * Performance: Uses embedding cache to avoid redundant API calls
-     */
-    async retrieve(query, limit = 10, useRerank = true) {
-        const allMemories = await this.repository.getAll();
-        if (allMemories.length === 0) {
-            return [];
-        }
-        // Check cache first to avoid redundant API calls
-        let queryEmbedding = this.embeddingCache.get(query);
-        if (!queryEmbedding) {
-            const embedding = await this.aiService.embed(query);
-            if (Array.isArray(embedding[0])) {
-                throw new Error('Expected single embedding');
-            }
-            queryEmbedding = embedding;
-            // Cache the embedding for future use
-            this.embeddingCache.set(query, queryEmbedding);
-        }
-        // Ensure we have a valid embedding
-        if (!queryEmbedding) {
-            throw new Error('Failed to generate query embedding');
-        }
-        // Initial retrieval: Get more candidates than needed for reranking
-        const initialLimit = useRerank ? Math.min(limit * 2, 50) : limit;
-        const initialMemories = this.retriever.retrieve(allMemories, queryEmbedding, initialLimit);
-        if (!useRerank || initialMemories.length === 0) {
-            return initialMemories.slice(0, limit);
-        }
-        // Rerank: Use Cohere Rerank API to improve precision
-        try {
-            const documents = initialMemories.map(m => m.description);
-            const rerankResults = await this.aiService.rerank(query, documents, limit);
-            // Reorder memories based on rerank scores
-            return rerankResults.map((result) => initialMemories[result.index]);
-        }
-        catch (error) {
-            // Fallback to initial results if rerank fails
-            console.warn('Memory rerank failed, using initial results:', error instanceof Error ? error.message : String(error));
-            return initialMemories.slice(0, limit);
-        }
-    }
-    /**
-     * Retrieve relevant memories for a specific codebase
-     * Filters memories by codebaseId before retrieval
-     * Performance: Uses embedding cache to avoid redundant API calls
-     */
-    async retrieveByCodebase(query, codebaseId, limit = 10, useRerank = true) {
-        // Get all memories for this codebase first
-        const codebaseMemories = await this.repository.getAllByCodebase(codebaseId);
-        if (codebaseMemories.length === 0) {
-            return [];
-        }
-        // Check cache first to avoid redundant API calls
-        let queryEmbedding = this.embeddingCache.get(query);
-        if (!queryEmbedding) {
-            const embedding = await this.aiService.embed(query);
-            if (Array.isArray(embedding[0])) {
-                throw new Error('Expected single embedding');
-            }
-            queryEmbedding = embedding;
-            // Cache the embedding for future use
-            this.embeddingCache.set(query, queryEmbedding);
-        }
-        // Ensure we have a valid embedding
-        if (!queryEmbedding) {
-            throw new Error('Failed to generate query embedding');
-        }
-        // Initial retrieval: Get more candidates than needed for reranking
-        const initialLimit = useRerank ? Math.min(limit * 2, 50) : limit;
-        const initialMemories = this.retriever.retrieve(codebaseMemories, queryEmbedding, initialLimit);
-        if (!useRerank || initialMemories.length === 0) {
-            return initialMemories.slice(0, limit);
-        }
-        // Rerank: Use Cohere Rerank API to improve precision
-        try {
-            const documents = initialMemories.map(m => m.description);
-            const rerankResults = await this.aiService.rerank(query, documents, limit);
-            // Reorder memories based on rerank scores
-            return rerankResults.map((result) => initialMemories[result.index]);
-        }
-        catch (error) {
-            // Fallback to initial results if rerank fails
-            console.warn('Memory rerank failed, using initial results:', error instanceof Error ? error.message : String(error));
-            return initialMemories.slice(0, limit);
-        }
-    }
-    /**
-     * Update memory access time
-     */
-    async updateAccess(memory) {
-        memory.lastAccessed = new Date();
-        await this.repository.update(memory);
-    }
-    /**
-     * Calculate importance score (1-10)
-     */
-    calculateImportance(description) {
-        const lower = description.toLowerCase();
-        // High importance indicators
-        if (lower.includes('error') || lower.includes('failed') || lower.includes('success')) {
-            return 8;
-        }
-        if (lower.includes('test') || lower.includes('verification')) {
-            return 7;
-        }
-        // Medium importance
-        if (lower.includes('edit') || lower.includes('change') || lower.includes('modify')) {
-            return 5;
-        }
-        // Default
-        return 3;
-    }
-}
-//# sourceMappingURL=memory-stream-service.js.map

package/dist/infrastructure/storage/plan-repository.js

@@ -1,96 +0,0 @@
-/**
- * Plan Repository
- * Persists and retrieves plans for execution across sessions
- *
- * Phase 1: v0.5.0-alpha.0
- */
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { randomUUID } from 'crypto';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-function getPlansDir() {
-    const agentDir = join(__dirname, '../../..');
-    if (existsSync(join(agentDir, 'package.json'))) {
-        return join(agentDir, 'data', 'plans');
-    }
-    return join(process.cwd(), '.codehere', 'plans');
-}
-export class FilePlanRepository {
-    plansDir;
-    constructor() {
-        this.plansDir = getPlansDir();
-        if (!existsSync(this.plansDir)) {
-            mkdirSync(this.plansDir, { recursive: true });
-        }
-    }
-    /**
-     * Save a plan to disk
-     */
-    async save(plan) {
-        const planId = plan.id || randomUUID();
-        const planPath = join(this.plansDir, `${planId}.json`);
-        const planToSave = {
-            ...plan,
-            id: planId,
-            savedAt: new Date().toISOString(),
-        };
-        writeFileSync(planPath, JSON.stringify(planToSave, null, 2), 'utf-8');
-        return planId;
-    }
-    /**
-     * Get a plan by ID
-     */
-    async get(planId) {
-        const planPath = join(this.plansDir, `${planId}.json`);
-        if (!existsSync(planPath)) {
-            return null;
-        }
-        try {
-            const content = readFileSync(planPath, 'utf-8');
-            return JSON.parse(content);
-        }
-        catch (error) {
-            console.error(`Failed to read plan ${planId}:`, error);
-            return null;
-        }
-    }
-    /**
-     * List recent plans
-     */
-    async list(limit = 10) {
-        // In alpha, simple file-based listing
-        // Can be enhanced later with proper sorting
-        return [];
-    }
-    /**
-     * Update a plan
-     */
-    async update(planId, updates) {
-        const plan = await this.get(planId);
-        if (!plan) {
-            throw new Error(`Plan ${planId} not found`);
-        }
-        const updatedPlan = { ...plan, ...updates };
-        await this.save(updatedPlan);
-    }
-    /**
-     * Delete a plan
-     */
-    async delete(planId) {
-        const planPath = join(this.plansDir, `${planId}.json`);
-        if (existsSync(planPath)) {
-            const { unlinkSync } = await import('fs');
-            unlinkSync(planPath);
-        }
-    }
-}
-let instance = null;
-export function getPlanRepository() {
-    if (!instance) {
-        instance = new FilePlanRepository();
-    }
-    return instance;
-}
-//# sourceMappingURL=plan-repository.js.map