codehere 0.7.1 → 1.0.1

package/dist/infrastructure/security/input-validator.js

@@ -1,152 +0,0 @@
-/**
- * Infrastructure: Input Validator
- * Enterprise-grade input validation and sanitization
- *
- * Clean Architecture: Infrastructure Layer
- * Security: Prevents injection attacks, validates user input
- */
-/**
- * Validate file path to prevent directory traversal
- */
-export function validateFilePath(filepath) {
-    const errors = [];
-    // Check for directory traversal attempts
-    if (filepath.includes('..') || filepath.includes('~')) {
-        errors.push('Directory traversal detected in file path');
-    }
-    // Check for absolute paths (should be relative)
-    if (filepath.startsWith('/') || /^[A-Z]:\\/.test(filepath)) {
-        errors.push('Absolute paths not allowed');
-    }
-    // Check for null bytes
-    if (filepath.includes('\0')) {
-        errors.push('Null bytes not allowed in file path');
-    }
-    // Check for dangerous characters
-    const dangerousChars = /[<>:"|?*\x00-\x1f]/;
-    if (dangerousChars.test(filepath)) {
-        errors.push('Invalid characters in file path');
-    }
-    // Sanitize path
-    let sanitized = filepath
-        .replace(/\.\./g, '') // Remove ..
-        .replace(/~/g, '') // Remove ~
-        .replace(/\0/g, '') // Remove null bytes
-        .replace(/[<>:"|?*\x00-\x1f]/g, '_'); // Replace dangerous chars
-    // Normalize path separators
-    sanitized = sanitized.replace(/\\/g, '/');
-    return {
-        valid: errors.length === 0,
-        errors,
-        sanitized: errors.length > 0 ? sanitized : undefined,
-    };
-}
-/**
- * Validate query string to prevent injection
- */
-export function validateQuery(query) {
-    const errors = [];
-    // Check for null bytes
-    if (query.includes('\0')) {
-        errors.push('Null bytes not allowed in query');
-    }
-    // Check for command injection patterns
-    const commandInjectionPatterns = [
-        /[;&|`$(){}[\]]/, // Shell metacharacters
-        /<script/i, // XSS attempts
-        /javascript:/i, // JavaScript protocol
-        /on\w+\s*=/i, // Event handlers
-    ];
-    for (const pattern of commandInjectionPatterns) {
-        if (pattern.test(query)) {
-            errors.push('Potentially dangerous characters detected in query');
-            break;
-        }
-    }
-    // Sanitize query
-    let sanitized = query
-        .replace(/\0/g, '') // Remove null bytes
-        .replace(/[;&|`$(){}[\]]/g, '') // Remove shell metacharacters
-        .replace(/<script/gi, '&lt;script') // Escape script tags
-        .replace(/javascript:/gi, '') // Remove javascript protocol
-        .replace(/on\w+\s*=/gi, ''); // Remove event handlers
-    // Trim and limit length
-    sanitized = sanitized.trim();
-    const MAX_QUERY_LENGTH = 10000; // Reasonable limit
-    if (sanitized.length > MAX_QUERY_LENGTH) {
-        errors.push(`Query exceeds maximum length of ${MAX_QUERY_LENGTH} characters`);
-        sanitized = sanitized.substring(0, MAX_QUERY_LENGTH);
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-        sanitized: errors.length > 0 ? sanitized : undefined,
-    };
-}
-/**
- * Validate API key format
- */
-export function validateAPIKey(apiKey) {
-    const errors = [];
-    if (!apiKey || apiKey.trim().length === 0) {
-        errors.push('API key is required');
-    }
-    // Check minimum length
-    if (apiKey.length < 10) {
-        errors.push('API key is too short');
-    }
-    // Check for null bytes
-    if (apiKey.includes('\0')) {
-        errors.push('Null bytes not allowed in API key');
-    }
-    // Check for whitespace (API keys shouldn't have spaces)
-    if (apiKey !== apiKey.trim()) {
-        errors.push('API key should not have leading or trailing whitespace');
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-        sanitized: errors.length > 0 ? apiKey.trim() : undefined,
-    };
-}
-/**
- * Validate file content before processing
- */
-export function validateFileContent(content, maxSize = 10 * 1024 * 1024) {
-    const errors = [];
-    // Check size
-    const sizeInBytes = new Blob([content]).size;
-    if (sizeInBytes > maxSize) {
-        errors.push(`File content exceeds maximum size of ${maxSize} bytes`);
-    }
-    // Check for null bytes (shouldn't be in text files)
-    if (content.includes('\0')) {
-        errors.push('Null bytes detected in file content');
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}
-/**
- * Sanitize user input for logging (prevent sensitive data leakage)
- */
-export function sanitizeForLogging(input) {
-    // Remove potential secrets (API keys, tokens, etc.)
-    let sanitized = input
-        // Remove API keys (Cohere format: alphanumeric, 40+ chars)
-        .replace(/[A-Za-z0-9]{40,}/g, '[REDACTED]')
-        // Remove email addresses
-        .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL_REDACTED]')
-        // Remove potential tokens
-        .replace(/token[=:]\s*[A-Za-z0-9_-]+/gi, 'token=[REDACTED]')
-        .replace(/password[=:]\s*[^\s]+/gi, 'password=[REDACTED]')
-        .replace(/secret[=:]\s*[^\s]+/gi, 'secret=[REDACTED]');
-    // Limit length for logging
-    const MAX_LOG_LENGTH = 1000;
-    if (sanitized.length > MAX_LOG_LENGTH) {
-        sanitized = sanitized.substring(0, MAX_LOG_LENGTH) + '...[TRUNCATED]';
-    }
-    return sanitized;
-}
-//# sourceMappingURL=input-validator.js.map

package/dist/infrastructure/storage/embeddings-path.js

@@ -1,37 +0,0 @@
-/**
- * Infrastructure: Embeddings Path Helper
- * Determines per-codebase embeddings database path
- */
-import { join } from 'path';
-import { existsSync, mkdirSync } from 'fs';
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-/**
- * Get embeddings database path for a specific codebase
- * Uses codebase root detection to ensure per-repo isolation
- *
- * @param cwd - Current working directory (defaults to process.cwd())
- * @returns Object with root path, database path, and cache directory
- */
-export function getEmbeddingsDbPath(cwd = process.cwd()) {
-    const codebaseInfo = findCodebaseRoot(cwd);
-    if (!codebaseInfo) {
-        // Fallback to cwd if codebase root can't be determined
-        const root = cwd;
-        const dbPath = join(root, '.codehere-cache', 'embeddings.sqlite');
-        const cacheDir = join(root, '.codehere-cache');
-        // Ensure cache directory exists
-        if (!existsSync(cacheDir)) {
-            mkdirSync(cacheDir, { recursive: true });
-        }
-        return { root, dbPath, cacheDir };
-    }
-    const root = codebaseInfo.rootPath;
-    const dbPath = join(root, '.codehere-cache', 'embeddings.sqlite');
-    const cacheDir = join(root, '.codehere-cache');
-    // Ensure cache directory exists
-    if (!existsSync(cacheDir)) {
-        mkdirSync(cacheDir, { recursive: true });
-    }
-    return { root, dbPath, cacheDir };
-}
-//# sourceMappingURL=embeddings-path.js.map

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

@@ -1,206 +0,0 @@
-/**
- * Infrastructure: Task Repository
- * Task storage and retrieval using JSONL format
- *
- * Phase 1: v0.5.0-alpha
- * See: .internal/ARCHITECTURE.md (internal docs)
- */
-import { appendFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { findCodebaseRoot } from '../../domain/services/codebase-detector.js';
-/**
- * JSONL-based task repository
- * Stores tasks in .codehere/tasks.jsonl at codebase root
- */
-export class JsonlTaskRepository {
-    tasksPath;
-    tasksCache = new Map();
-    cacheLoaded = false;
-    constructor(customPath) {
-        if (customPath) {
-            this.tasksPath = customPath;
-        }
-        else {
-            // Use environment variable or detect from codebase root
-            const envPath = process.env.CODEHERE_TASKS_PATH;
-            if (envPath) {
-                this.tasksPath = envPath;
-            }
-            else {
-                // Detect codebase root and use .codehere/tasks.jsonl
-                const codebaseInfo = findCodebaseRoot(process.cwd());
-                const codebaseRoot = codebaseInfo?.rootPath || process.cwd();
-                const codehereDir = join(codebaseRoot, '.codehere');
-                // Ensure .codehere directory exists
-                if (!existsSync(codehereDir)) {
-                    mkdirSync(codehereDir, { recursive: true });
-                }
-                this.tasksPath = join(codehereDir, 'tasks.jsonl');
-            }
-        }
-        // Ensure directory exists
-        const tasksDir = dirname(this.tasksPath);
-        if (!existsSync(tasksDir)) {
-            mkdirSync(tasksDir, { recursive: true });
-        }
-    }
-    /**
-     * Load tasks from JSONL file into cache
-     * For duplicate IDs, keeps the latest version (by updatedAt)
-     */
-    loadTasks() {
-        if (this.cacheLoaded) {
-            return;
-        }
-        if (!existsSync(this.tasksPath)) {
-            this.cacheLoaded = true;
-            return;
-        }
-        try {
-            const content = readFileSync(this.tasksPath, 'utf-8');
-            const lines = content
-                .trim()
-                .split('\n')
-                .filter((line) => line.trim());
-            // Load all tasks, then keep only the latest version of each ID
-            const allTasks = [];
-            for (const line of lines) {
-                try {
-                    const task = JSON.parse(line);
-                    allTasks.push(task);
-                }
-                catch {
-                    // Skip invalid lines
-                }
-            }
-            // Group by ID and keep latest version
-            const taskMap = new Map();
-            for (const task of allTasks) {
-                const existing = taskMap.get(task.id);
-                if (!existing || task.updatedAt > existing.updatedAt) {
-                    taskMap.set(task.id, task);
-                }
-            }
-            this.tasksCache = taskMap;
-            this.cacheLoaded = true;
-        }
-        catch (error) {
-            // Silent failure - don't break user workflow
-            console.error('[TaskRepository] Failed to load tasks:', error);
-            this.cacheLoaded = true;
-        }
-    }
-    /**
-     * Create a new task
-     */
-    async create(task) {
-        // Ensure cache is loaded
-        this.loadTasks();
-        // Set timestamps if not provided
-        const now = Date.now();
-        const taskToCreate = {
-            ...task,
-            createdAt: task.createdAt || now,
-            updatedAt: task.updatedAt || now,
-        };
-        // Add to cache
-        this.tasksCache.set(taskToCreate.id, taskToCreate);
-        // Append to JSONL file (append-only, immutable history)
-        try {
-            appendFileSync(this.tasksPath, JSON.stringify(taskToCreate) + '\n', 'utf-8');
-        }
-        catch (error) {
-            // Silent failure - remove from cache if write failed
-            this.tasksCache.delete(taskToCreate.id);
-            console.error('[TaskRepository] Failed to create task:', error);
-            throw error;
-        }
-    }
-    /**
-     * Get task by ID (returns latest version if multiple exist)
-     */
-    async getById(id) {
-        this.loadTasks();
-        // Load all tasks and find the latest version of this ID
-        const allTasks = Array.from(this.tasksCache.values());
-        const tasksWithId = allTasks.filter((task) => task.id === id);
-        if (tasksWithId.length === 0) {
-            return null;
-        }
-        // Return the task with the latest updatedAt timestamp
-        return tasksWithId.reduce((latest, current) => {
-            return current.updatedAt > latest.updatedAt ? current : latest;
-        });
-    }
-    /**
-     * Get tasks by status
-     */
-    async getByStatus(status) {
-        this.loadTasks();
-        const tasks = Array.from(this.tasksCache.values());
-        return tasks.filter((task) => task.status === status);
-    }
-    /**
-     * Get tasks by mode
-     */
-    async getByMode(mode) {
-        this.loadTasks();
-        const tasks = Array.from(this.tasksCache.values());
-        return tasks.filter((task) => task.mode === mode);
-    }
-    /**
-     * Get recent tasks (latest updated first)
-     */
-    async getRecent(limit = 10) {
-        this.loadTasks();
-        const tasks = Array.from(this.tasksCache.values());
-        return tasks.sort((a, b) => b.updatedAt - a.updatedAt).slice(0, limit);
-    }
-    /**
-     * Get all tasks (latest version of each)
-     */
-    async getAll() {
-        this.loadTasks();
-        return Array.from(this.tasksCache.values());
-    }
-    /**
-     * Update existing task
-     * Creates a new entry in JSONL (append-only)
-     */
-    async update(task) {
-        // Ensure cache is loaded
-        this.loadTasks();
-        // Update timestamp
-        const updatedTask = {
-            ...task,
-            updatedAt: Date.now(),
-        };
-        // Update cache
-        this.tasksCache.set(updatedTask.id, updatedTask);
-        // Append updated version to JSONL (append-only, immutable history)
-        try {
-            appendFileSync(this.tasksPath, JSON.stringify(updatedTask) + '\n', 'utf-8');
-        }
-        catch (error) {
-            // Revert cache if write failed
-            const original = await this.getById(task.id);
-            if (original) {
-                this.tasksCache.set(task.id, original);
-            }
-            console.error('[TaskRepository] Failed to update task:', error);
-            throw error;
-        }
-    }
-}
-// Singleton instance (lazy initialization with codebase detection)
-let taskRepositoryInstance = null;
-/**
- * Get task repository instance
- */
-export function getTaskRepository(customPath) {
-    if (!taskRepositoryInstance || customPath) {
-        taskRepositoryInstance = new JsonlTaskRepository(customPath);
-    }
-    return taskRepositoryInstance;
-}
-//# sourceMappingURL=task-repository.js.map