codehere 0.2.1 → 0.3.0-rc.1

package/dist/infrastructure/governance/prompt-to-code-lineage.js

@@ -1,239 +0,0 @@
-/**
- * INTERNAL ONLY — infrastructure helper, not a user-facing feature.
- *
- * Prompt-to-Code Lineage - Tracks the journey from user prompt to generated code artifact.
- * Infrastructure-only, not yet exposed as user-facing feature. Planned for 0.5.x (Teams & Governance).
- * Not guaranteed to be stable.
- *
- * Do not rely on this directly.
- *
- * @internal
- */
-/**
- * Prompt-to-Code Lineage Tracker
- * Maintains complete audit trail from prompt to code artifact
- */
-export class PromptToCodeLineage {
-    lineages = new Map();
-    /**
-     * Create new lineage trace for a user prompt
-     */
-    createLineage(prompt, userContext) {
-        const lineageId = `lineage-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        const rootNodeId = `node-${Date.now()}-root`;
-        const rootNode = {
-            nodeId: rootNodeId,
-            type: 'prompt',
-            timestamp: Date.now(),
-            description: `User prompt: ${prompt.substring(0, 100)}${prompt.length > 100 ? '...' : ''}`,
-            input: { prompt },
-            metadata: {
-                sessionId: userContext?.sessionId,
-                workspace: userContext?.workspace,
-            },
-            childNodeIds: [],
-        };
-        const lineage = {
-            lineageId,
-            prompt,
-            userContext: userContext ? {
-                ...userContext,
-                timestamp: Date.now(),
-            } : undefined,
-            nodes: new Map([[rootNodeId, rootNode]]),
-            rootNodeId,
-            humanInterventions: [],
-            createdAt: Date.now(),
-        };
-        this.lineages.set(lineageId, lineage);
-        return lineageId;
-    }
-    /**
-     * Add node to lineage (plan, tool call, code generation, etc.)
-     */
-    addNode(lineageId, node, parentNodeId) {
-        const lineage = this.lineages.get(lineageId);
-        if (!lineage) {
-            throw new Error(`Lineage ${lineageId} not found`);
-        }
-        const nodeId = `node-${Date.now()}-${node.type}`;
-        const fullNode = {
-            ...node,
-            nodeId,
-            childNodeIds: [],
-            parentNodeId,
-        };
-        lineage.nodes.set(nodeId, fullNode);
-        // Link to parent
-        const parentNode = lineage.nodes.get(parentNodeId);
-        if (parentNode) {
-            parentNode.childNodeIds.push(nodeId);
-        }
-        return nodeId;
-    }
-    /**
-     * Track code generation artifact
-     */
-    trackCodeGeneration(lineageId, parentNodeId, artifact, metadata) {
-        return this.addNode(lineageId, {
-            type: 'code_generation',
-            timestamp: Date.now(),
-            description: `Generated code artifact: ${artifact.filepath}`,
-            input: {
-                filepath: artifact.filepath,
-                originalContent: artifact.originalContent,
-            },
-            output: {
-                filepath: artifact.filepath,
-                content: artifact.content,
-                diff: artifact.diff,
-            },
-            metadata: metadata || {},
-        }, parentNodeId);
-    }
-    /**
-     * Track verification result
-     */
-    trackVerification(lineageId, parentNodeId, verification) {
-        return this.addNode(lineageId, {
-            type: 'verification',
-            timestamp: Date.now(),
-            description: verification.passed ? 'Verification passed' : `Verification failed: ${verification.reason}`,
-            input: { parentNodeId },
-            output: verification,
-            metadata: {},
-        }, parentNodeId);
-    }
-    /**
-     * Track human intervention (approval, rejection, modification)
-     */
-    trackHumanIntervention(lineageId, nodeId, intervention) {
-        const lineage = this.lineages.get(lineageId);
-        if (!lineage) {
-            throw new Error(`Lineage ${lineageId} not found`);
-        }
-        lineage.humanInterventions.push({
-            timestamp: Date.now(),
-            nodeId,
-            ...intervention,
-        });
-        // Update node metadata with intervention
-        const node = lineage.nodes.get(nodeId);
-        if (node) {
-            node.metadata.humanIntervention = intervention;
-        }
-    }
-    /**
-     * Mark final artifact (code that was actually applied/committed)
-     */
-    setFinalArtifact(lineageId, artifactNodeId) {
-        const lineage = this.lineages.get(lineageId);
-        if (!lineage) {
-            throw new Error(`Lineage ${lineageId} not found`);
-        }
-        lineage.finalArtifactId = artifactNodeId;
-        lineage.completedAt = Date.now();
-    }
-    /**
-     * Get complete lineage trace
-     */
-    getLineage(lineageId) {
-        return this.lineages.get(lineageId) || null;
-    }
-    /**
-     * Get lineage path (trace from root to final artifact)
-     */
-    getLineagePath(lineageId) {
-        const lineage = this.lineages.get(lineageId);
-        if (!lineage) {
-            return [];
-        }
-        const path = [];
-        let currentNodeId = lineage.finalArtifactId || lineage.rootNodeId;
-        // Traverse from final artifact (or root) back to root
-        const visited = new Set();
-        while (currentNodeId && !visited.has(currentNodeId)) {
-            visited.add(currentNodeId);
-            const node = lineage.nodes.get(currentNodeId);
-            if (node) {
-                path.unshift(node); // Add to beginning
-                currentNodeId = node.parentNodeId;
-            }
-            else {
-                break;
-            }
-        }
-        return path;
-    }
-    /**
-     * Get all human interventions for audit
-     */
-    getHumanInterventions(lineageId) {
-        const lineage = this.lineages.get(lineageId);
-        return lineage?.humanInterventions || [];
-    }
-    /**
-     * Get lineage tree (complete decision tree from prompt to artifact)
-     */
-    getLineageTree(lineageId) {
-        const lineage = this.lineages.get(lineageId);
-        if (!lineage) {
-            return null;
-        }
-        return this.buildTree(lineage.rootNodeId, lineage.nodes);
-    }
-    /**
-     * Search lineages by criteria
-     */
-    searchLineages(criteria) {
-        const results = [];
-        for (const lineage of this.lineages.values()) {
-            // Filter by user context
-            if (criteria.userId && lineage.userContext?.userId !== criteria.userId) {
-                continue;
-            }
-            if (criteria.sessionId && lineage.userContext?.sessionId !== criteria.sessionId) {
-                continue;
-            }
-            // Filter by time range
-            if (criteria.startTime && lineage.createdAt < criteria.startTime) {
-                continue;
-            }
-            if (criteria.endTime && lineage.createdAt > criteria.endTime) {
-                continue;
-            }
-            // Filter by intent
-            if (criteria.intentType && lineage.intent?.type !== criteria.intentType) {
-                continue;
-            }
-            // Filter by filepath (check all code generation nodes)
-            if (criteria.filepath) {
-                let found = false;
-                for (const node of lineage.nodes.values()) {
-                    if (node.type === 'code_generation' && node.output?.filepath === criteria.filepath) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found)
-                    continue;
-            }
-            results.push(lineage);
-        }
-        return results.sort((a, b) => b.createdAt - a.createdAt);
-    }
-    // Private helpers
-    buildTree(nodeId, nodes) {
-        const node = nodes.get(nodeId);
-        if (!node)
-            return null;
-        return {
-            ...node,
-            childNodeIds: node.childNodeIds.map(childId => {
-                const childNode = nodes.get(childId);
-                return childNode ? childNode.nodeId : '';
-            }).filter(Boolean),
-        };
-    }
-}
-//# sourceMappingURL=prompt-to-code-lineage.js.map

package/dist/infrastructure/index.js

@@ -1,7 +0,0 @@
-/**
- * Infrastructure Layer - Public Exports
- */
-export * from './ai/cohere-ai-service.js';
-export * from './storage/sqlite-embedding-repository.js';
-export * from './storage/sqlite-memory-repository.js';
-//# sourceMappingURL=index.js.map

package/dist/infrastructure/observability/prompt-versioner.js

@@ -1,145 +0,0 @@
-/**
- * Infrastructure: Prompt Versioner
- * Tracks prompt versions for reproducibility and A/B testing
- *
- * Clean Architecture: Infrastructure Layer
- * Strategic: Enable prompt versioning and comparison
- */
-import { createHash } from 'crypto';
-import { writeFileSync, readFileSync, existsSync, mkdirSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-/**
- * Prompt Versioner
- * Tracks prompt versions for reproducibility
- */
-export class PromptVersioner {
-    versionsDir;
-    versionIndex;
-    constructor() {
-        const agentDir = join(__dirname, '../../..');
-        this.versionsDir = join(agentDir, 'data', 'prompt-versions');
-        this.versionIndex = new Map();
-        if (!existsSync(this.versionsDir)) {
-            mkdirSync(this.versionsDir, { recursive: true });
-        }
-        // Load existing versions
-        this.loadVersions();
-    }
-    /**
-     * Register a prompt version
-     */
-    registerVersion(prompt, metadata) {
-        const promptHash = this.hashPrompt(prompt);
-        // Check if version already exists
-        if (this.versionIndex.has(promptHash)) {
-            const existing = this.versionIndex.get(promptHash);
-            return existing.versionId;
-        }
-        // Create new version
-        const versionId = `v${Date.now()}-${promptHash.substring(0, 8)}`;
-        const version = {
-            versionId,
-            promptHash,
-            prompt,
-            createdAt: Date.now(),
-            usedBy: [],
-            metadata,
-        };
-        // Save to disk
-        const versionPath = join(this.versionsDir, `${versionId}.json`);
-        writeFileSync(versionPath, JSON.stringify(version, null, 2), 'utf-8');
-        // Update index
-        this.versionIndex.set(promptHash, version);
-        // Save index
-        this.saveIndex();
-        return versionId;
-    }
-    /**
-     * Link a run to a prompt version
-     */
-    linkRunToVersion(prompt, runId) {
-        const promptHash = this.hashPrompt(prompt);
-        const version = this.versionIndex.get(promptHash);
-        if (version) {
-            if (!version.usedBy.includes(runId)) {
-                version.usedBy.push(runId);
-                // Update version file
-                const versionPath = join(this.versionsDir, `${version.versionId}.json`);
-                writeFileSync(versionPath, JSON.stringify(version, null, 2), 'utf-8');
-            }
-            return version.versionId;
-        }
-        // Version doesn't exist yet, register it
-        return this.registerVersion(prompt);
-    }
-    /**
-     * Get prompt version by ID
-     */
-    getVersion(versionId) {
-        const versionPath = join(this.versionsDir, `${versionId}.json`);
-        if (!existsSync(versionPath)) {
-            return null;
-        }
-        try {
-            const content = readFileSync(versionPath, 'utf-8');
-            return JSON.parse(content);
-        }
-        catch (error) {
-            console.error(`Failed to load prompt version ${versionId}:`, error);
-            return null;
-        }
-    }
-    /**
-     * Get prompt version by hash
-     */
-    getVersionByHash(promptHash) {
-        return this.versionIndex.get(promptHash) || null;
-    }
-    /**
-     * Get all versions for a prompt (by hash)
-     */
-    getVersionsForPrompt(prompt) {
-        const promptHash = this.hashPrompt(prompt);
-        const version = this.versionIndex.get(promptHash);
-        return version ? [version] : [];
-    }
-    /**
-     * List all prompt versions
-     */
-    listAllVersions() {
-        return Array.from(this.versionIndex.values());
-    }
-    /**
-     * Hash a prompt for versioning
-     */
-    hashPrompt(prompt) {
-        return createHash('sha256').update(prompt).digest('hex');
-    }
-    /**
-     * Load all versions from disk
-     */
-    loadVersions() {
-        // In a real implementation, we'd scan the versions directory
-        // For now, we load on-demand
-        // This could be optimized with an index file
-    }
-    /**
-     * Save version index
-     */
-    saveIndex() {
-        const indexPath = join(this.versionsDir, 'index.json');
-        const indexData = Array.from(this.versionIndex.entries()).map(([hash, version]) => ({
-            hash,
-            versionId: version.versionId,
-            createdAt: version.createdAt,
-            metadata: version.metadata,
-        }));
-        writeFileSync(indexPath, JSON.stringify(indexData, null, 2), 'utf-8');
-    }
-}
-// Singleton instance
-export const promptVersioner = new PromptVersioner();
-//# sourceMappingURL=prompt-versioner.js.map

package/dist/infrastructure/protocols/a2a-metadata.js

@@ -1,137 +0,0 @@
-/**
- * Infrastructure: A2A Agentic AI Metadata
- * Discoverable JSON metadata that outlines agent capabilities
- *
- * Based on research: A2A requires Agentic AI Metadata for capability discovery
- * Accessible via URL for agent discovery and integration
- */
-/**
- * Codehere A2A Metadata
- * Exposes Codehere capabilities for agent discovery
- */
-export class CodehereA2AMetadata {
-    agent_id = 'codehere';
-    name = 'Codehere';
-    description = 'AI coding assistant with persistent episodic memory, AST-based understanding, and multi-agent orchestration. Specializes in codebase understanding, code editing, and long-term context retention.';
-    version = '0.3.0';
-    capabilities = {
-        tasks: [
-            {
-                id: 'memory_query',
-                name: 'Query Memory',
-                description: 'Query persistent episodic memory for past experiences and learned patterns',
-                input_schema: {
-                    type: 'object',
-                    properties: {
-                        query: { type: 'string', description: 'Memory query' },
-                        limit: { type: 'number', description: 'Maximum results', default: 10 },
-                    },
-                    required: ['query'],
-                },
-                estimated_duration: '1-2s',
-            },
-            {
-                id: 'memory_store',
-                name: 'Store Memory',
-                description: 'Store observation, plan, or reflection in persistent memory',
-                input_schema: {
-                    type: 'object',
-                    properties: {
-                        description: { type: 'string', description: 'Memory description' },
-                        type: {
-                            type: 'string',
-                            enum: ['observation', 'plan', 'reflection', 'pattern'],
-                            description: 'Memory type',
-                        },
-                        metadata: { type: 'object', description: 'Additional metadata' },
-                    },
-                    required: ['description', 'type'],
-                },
-                estimated_duration: '< 1s',
-            },
-            {
-                id: 'code_search',
-                name: 'Search Codebase',
-                description: 'Semantic search across codebase using AST-based understanding',
-                input_schema: {
-                    type: 'object',
-                    properties: {
-                        query: { type: 'string', description: 'Search query' },
-                        max_results: { type: 'number', description: 'Maximum results', default: 10 },
-                    },
-                    required: ['query'],
-                },
-                estimated_duration: '2-5s',
-            },
-            {
-                id: 'code_explain',
-                name: 'Explain Code',
-                description: 'Get detailed explanation of a code file',
-                input_schema: {
-                    type: 'object',
-                    properties: {
-                        filepath: { type: 'string', description: 'Path to file' },
-                    },
-                    required: ['filepath'],
-                },
-                estimated_duration: '5-10s',
-            },
-            {
-                id: 'code_edit',
-                name: 'Edit Code',
-                description: 'Edit code file with AI-generated changes (with security gates)',
-                input_schema: {
-                    type: 'object',
-                    properties: {
-                        filepath: { type: 'string', description: 'Path to file' },
-                        instruction: { type: 'string', description: 'Edit instruction' },
-                    },
-                    required: ['filepath', 'instruction'],
-                },
-                estimated_duration: '10-30s',
-                async: false,
-            },
-        ],
-        communication: {
-            synchronous: true,
-            asynchronous: true,
-            streaming: true,
-        },
-    };
-    endpoints = {
-        base_url: 'https://codehere.io/a2a', // TODO: Configure actual endpoint
-        bindings: ['json-rpc', 'http-rest'], // Support JSON-RPC and HTTP/REST
-        webhook_url: 'https://codehere.io/a2a/webhook', // For async notifications
-    };
-    security = {
-        auth_methods: ['oauth2', 'm2m_token'],
-        oauth_scopes: [
-            'codehere:memory:read',
-            'codehere:memory:write',
-            'codehere:code:read',
-            'codehere:code:write',
-        ],
-    };
-    metadata_url;
-    constructor(baseUrl) {
-        this.endpoints.base_url = baseUrl || this.endpoints.base_url;
-        this.endpoints.webhook_url = `${this.endpoints.base_url}/webhook`;
-        this.metadata_url = `${this.endpoints.base_url}/.well-known/agentic-ai-metadata`;
-    }
-    /**
-     * Get metadata as JSON
-     */
-    toJSON() {
-        return {
-            agent_id: this.agent_id,
-            name: this.name,
-            description: this.description,
-            version: this.version,
-            capabilities: this.capabilities,
-            endpoints: this.endpoints,
-            security: this.security,
-            metadata_url: this.metadata_url,
-        };
-    }
-}
-//# sourceMappingURL=a2a-metadata.js.map