codeep 1.0.125 → 1.0.127

package/dist/api/index.js

@@ -2,6 +2,7 @@ import { config, getApiKey } from '../config/index.js';
 import { withRetry, isNetworkError, isTimeoutError } from '../utils/retry.js';
 import { getProvider, getProviderBaseUrl, getProviderAuthHeader } from '../config/providers.js';
 import { logApiRequest, logApiResponse } from '../utils/logger.js';
+import { loadProjectIntelligence, generateContextFromIntelligence } from '../utils/projectIntelligence.js';
 // Error messages by language
 const ERROR_MESSAGES = {
     en: {
@@ -24,8 +25,16 @@ function getErrorMessage(key) {
 }
 // Store project context for use in system prompt
 let currentProjectContext = null;
+let cachedIntelligence = null;
 export function setProjectContext(ctx) {
     currentProjectContext = ctx;
+    // Try to load cached intelligence when project context is set
+    if (ctx) {
+        cachedIntelligence = loadProjectIntelligence(ctx.root);
+    }
+    else {
+        cachedIntelligence = null;
+    }
 }
 export async function chat(message, history = [], onChunk, onRetry, projectContext, abortSignal) {
     // Update project context if provided
@@ -132,6 +141,21 @@ The user will review and approve changes before they are applied.`
             : `
 
 **Write Access:** READ-ONLY - You can analyze code but cannot suggest file modifications.`;
+        // Use cached intelligence if available (from /scan command)
+        // This provides richer context than basic project structure
+        if (cachedIntelligence) {
+            const intelligenceContext = generateContextFromIntelligence(cachedIntelligence);
+            const projectInfo = `
+
+## Project Intelligence (cached)
+${intelligenceContext}
+${writeInfo}
+
+When the user mentions a file path, the file content will be automatically attached to their message.
+You can analyze, explain, or suggest improvements to the code.`;
+            return basePrompt + projectInfo;
+        }
+        // Fallback to basic project context
         const projectInfo = `
 
 ## Project Context

package/dist/app.js

@@ -35,8 +35,8 @@ import { saveContext, loadContext, clearContext, mergeContext } from './utils/co
 import { performCodeReview, formatReviewResult } from './utils/codeReview.js';
 import { learnFromProject, addCustomRule, getLearningStatus } from './utils/learning.js';
 import { getAllSkills, findSkill, formatSkillsList, formatSkillHelp, generateSkillPrompt, saveCustomSkill, deleteCustomSkill, parseSkillChain, parseSkillArgs, searchSkills, trackSkillUsage, getSkillStats } from './utils/skills.js';
-import { AgentProgress, LiveCodeStream } from './components/AgentProgress.js';
 import { createActionLog } from './utils/tools.js';
+import { scanProject, saveProjectIntelligence, loadProjectIntelligence, generateContextFromIntelligence } from './utils/projectIntelligence.js';
 export const App = () => {
     const { exit } = useApp();
     const { stdout } = useStdout();
@@ -82,6 +82,7 @@ export const App = () => {
     const [agentThinking, setAgentThinking] = useState('');
     const [agentResult, setAgentResult] = useState(null);
     const [agentDryRun, setAgentDryRun] = useState(false);
+    const [agentStreamingContent, setAgentStreamingContent] = useState(''); // Live action log in chat
     // Load API keys for ALL providers on startup and check if current provider is configured
     useEffect(() => {
         loadAllApiKeys().then(() => {
@@ -266,6 +267,7 @@ export const App = () => {
         setAgentThinking('');
         setAgentResult(null);
         setAgentDryRun(dryRun);
+        setAgentStreamingContent(''); // Reset streaming content
         // Add user message
         const userMessage = {
             role: 'user',
@@ -322,6 +324,78 @@ export const App = () => {
                         }
                         return updated;
                     });
+                    // Add formatted action to streaming content (stays in chat)
+                    const actionType = actionLog.type;
+                    const target = actionLog.target.split('/').pop() || actionLog.target; // Just filename
+                    const fullPath = actionLog.target;
+                    const status = actionLog.result === 'success' ? '✓' : '✗';
+                    const statusColor = actionLog.result === 'success' ? '' : ' (failed)';
+                    // Get file extension for syntax highlighting
+                    const getLanguage = (filename) => {
+                        const ext = filename.split('.').pop()?.toLowerCase() || '';
+                        const langMap = {
+                            'ts': 'typescript', 'tsx': 'typescript', 'js': 'javascript', 'jsx': 'javascript',
+                            'py': 'python', 'rb': 'ruby', 'go': 'go', 'rs': 'rust', 'java': 'java',
+                            'php': 'php', 'css': 'css', 'scss': 'css', 'html': 'html', 'vue': 'html',
+                            'json': 'json', 'yml': 'yaml', 'yaml': 'yaml', 'md': 'markdown',
+                            'sh': 'bash', 'bash': 'bash', 'sql': 'sql',
+                        };
+                        return langMap[ext] || ext || 'code';
+                    };
+                    let actionLine = '';
+                    if (actionType === 'write' && actionLog.details) {
+                        // Show full code with syntax highlighting
+                        const lang = getLanguage(target);
+                        actionLine = `${status} **Created ${fullPath}**\n\`\`\`${lang}\n${actionLog.details}\n\`\`\``;
+                    }
+                    else if (actionType === 'write') {
+                        actionLine = `${status} Created **${target}**${statusColor}`;
+                    }
+                    else if (actionType === 'edit' && actionLog.details) {
+                        // Show edited code with syntax highlighting
+                        const lang = getLanguage(target);
+                        actionLine = `${status} **Edited ${fullPath}**\n\`\`\`${lang}\n${actionLog.details}\n\`\`\``;
+                    }
+                    else if (actionType === 'edit') {
+                        actionLine = `${status} Edited **${target}**${statusColor}`;
+                    }
+                    else if (actionType === 'read') {
+                        // Don't show read actions in stream - too noisy
+                        return;
+                    }
+                    else if (actionType === 'delete') {
+                        actionLine = `${status} Deleted **${fullPath}**${statusColor}`;
+                    }
+                    else if (actionType === 'command') {
+                        const cmd = actionLog.target;
+                        // Show command output if available
+                        if (actionLog.details && actionLog.details.trim()) {
+                            actionLine = `${status} Ran \`${cmd}\`\n\`\`\`\n${actionLog.details.slice(0, 500)}${actionLog.details.length > 500 ? '\n...(truncated)' : ''}\n\`\`\``;
+                        }
+                        else {
+                            actionLine = `${status} Ran \`${cmd}\`${statusColor}`;
+                        }
+                    }
+                    else if (actionType === 'search') {
+                        // Don't show search actions - too noisy
+                        return;
+                    }
+                    else if (actionType === 'mkdir') {
+                        actionLine = `${status} Created directory **${fullPath}**${statusColor}`;
+                    }
+                    else if (actionType === 'fetch') {
+                        actionLine = `${status} Fetched ${target}${statusColor}`;
+                    }
+                    else if (actionType === 'list') {
+                        // Don't show list actions
+                        return;
+                    }
+                    else {
+                        actionLine = `◦ ${actionType}: ${target}`;
+                    }
+                    if (actionLine) {
+                        setAgentStreamingContent(prev => prev + (prev ? '\n\n' : '') + actionLine);
+                    }
                 },
                 onThinking: (text) => {
                     // Strip <think> and <tool_call> tags from thinking text
@@ -983,6 +1057,57 @@ export const App = () => {
                     }]);
                 break;
             }
+            case '/scan': {
+                if (!projectContext) {
+                    notify('No project context');
+                    break;
+                }
+                // Check for subcommands
+                if (args[0] === 'status') {
+                    const intel = loadProjectIntelligence(projectContext.root);
+                    if (intel) {
+                        const age = Math.round((Date.now() - new Date(intel.scannedAt).getTime()) / (1000 * 60 * 60));
+                        notify(`Last scan: ${age}h ago | ${intel.structure.totalFiles} files | ${intel.type}`);
+                    }
+                    else {
+                        notify('No scan data. Run /scan to analyze project.');
+                    }
+                    break;
+                }
+                if (args[0] === 'clear') {
+                    // Clear cached intelligence
+                    const intelPath = `${projectContext.root}/.codeep/intelligence.json`;
+                    try {
+                        const fs = require('fs');
+                        if (fs.existsSync(intelPath)) {
+                            fs.unlinkSync(intelPath);
+                            notify('Project intelligence cleared');
+                        }
+                        else {
+                            notify('No cached intelligence to clear');
+                        }
+                    }
+                    catch {
+                        notify('Failed to clear intelligence');
+                    }
+                    break;
+                }
+                // Run full scan
+                notify('Scanning project...');
+                scanProject(projectContext.root).then(intelligence => {
+                    saveProjectIntelligence(projectContext.root, intelligence);
+                    // Generate and display summary
+                    const context = generateContextFromIntelligence(intelligence);
+                    setMessages(prev => [...prev, {
+                            role: 'assistant',
+                            content: `# Project Scan Complete\n\n${context}\n\n---\n*Saved to .codeep/intelligence.json*`,
+                        }]);
+                    notify(`Scanned: ${intelligence.structure.totalFiles} files, ${intelligence.structure.totalDirectories} dirs`);
+                }).catch(error => {
+                    notify('Scan failed: ' + error.message);
+                });
+                break;
+            }
             case '/learn': {
                 if (!projectContext) {
                     notify('No project context');
@@ -1319,7 +1444,7 @@ export const App = () => {
     // Helper to check if we're showing an inline menu
     const isInlineMenu = ['help', 'status', 'settings', 'sessions', 'sessions-delete',
         'logout', 'search', 'export', 'model', 'provider', 'protocol', 'language'].includes(screen);
-    return (_jsxs(Box, { flexDirection: "column", children: [messages.length === 0 && !isLoading && _jsx(Logo, {}), messages.length === 0 && !isLoading && (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Box, { justifyContent: "center", children: _jsxs(Text, { children: ["Connected to ", _jsx(Text, { color: "#f02a30", children: config.get('model') }), ". Type ", _jsx(Text, { color: "#f02a30", children: "/help" }), " for commands."] }) }), _jsx(Text, { children: " " }), _jsx(Box, { justifyContent: "center", children: _jsx(Text, { color: "cyan", bold: true, children: "Welcome to Codeep - Your AI Coding Assistant" }) }), _jsx(Text, { children: " " }), _jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "\u2022" }), " Ask questions about your code or request implementations"] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "\u2022" }), " Use ", _jsxs(Text, { color: "cyan", children: ["/agent ", '<task>'] }), " for autonomous task execution"] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "\u2022" }), " Type ", _jsx(Text, { color: "cyan", children: "/diff" }), " to review changes, ", _jsx(Text, { color: "cyan", children: "/commit" }), " to generate commit messages"] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "\u2022" }), " Configure settings with ", _jsx(Text, { color: "cyan", children: "/settings" }), " - enable Agent Mode for auto-execution"] })] }), _jsx(Text, { children: " " }), _jsx(Box, { justifyContent: "center", children: _jsx(Text, { color: "gray", children: "Start typing your message or use a command to begin..." }) }), _jsx(Text, { children: " " })] })), _jsx(MessageList, { messages: messages, streamingContent: streamingContent }, sessionId), isLoading && !isAgentRunning && _jsx(Loading, { isStreaming: !!streamingContent }), (isAgentRunning || agentResult) && (_jsxs(Box, { flexDirection: "column", children: [_jsx(LiveCodeStream, { actions: agentActions, isRunning: isAgentRunning, terminalWidth: stdout?.columns || 80 }), isAgentRunning && (_jsx(AgentProgress, { isRunning: true, iteration: agentIteration, maxIterations: 50, actions: agentActions, currentThinking: agentThinking, dryRun: agentDryRun }))] }, "agent-ui")), pendingFileChanges.length > 0 && !isLoading && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, marginY: 1, children: [_jsxs(Text, { color: "#f02a30", bold: true, children: ["\u2713 Detected ", pendingFileChanges.length, " file change(s):"] }), pendingFileChanges.map((change, i) => {
+    return (_jsxs(Box, { flexDirection: "column", children: [messages.length === 0 && !isLoading && _jsx(Logo, {}), messages.length === 0 && !isLoading && (_jsxs(Box, { flexDirection: "column", marginY: 1, children: [_jsx(Box, { justifyContent: "center", children: _jsxs(Text, { children: ["Connected to ", _jsx(Text, { color: "#f02a30", children: config.get('model') }), ". Type ", _jsx(Text, { color: "#f02a30", children: "/help" }), " for commands."] }) }), _jsx(Text, { children: " " }), _jsx(Box, { justifyContent: "center", children: _jsx(Text, { color: "cyan", bold: true, children: "Welcome to Codeep - Your AI Coding Assistant" }) }), _jsx(Text, { children: " " }), _jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "\u2022" }), " Ask questions about your code or request implementations"] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "\u2022" }), " Use ", _jsxs(Text, { color: "cyan", children: ["/agent ", '<task>'] }), " for autonomous task execution"] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "\u2022" }), " Type ", _jsx(Text, { color: "cyan", children: "/diff" }), " to review changes, ", _jsx(Text, { color: "cyan", children: "/commit" }), " to generate commit messages"] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "\u2022" }), " Configure settings with ", _jsx(Text, { color: "cyan", children: "/settings" }), " - enable Agent Mode for auto-execution"] })] }), _jsx(Text, { children: " " }), _jsx(Box, { justifyContent: "center", children: _jsx(Text, { color: "gray", children: "Start typing your message or use a command to begin..." }) }), _jsx(Text, { children: " " })] })), _jsx(MessageList, { messages: messages, streamingContent: streamingContent, agentStreamingContent: isAgentRunning ? agentStreamingContent : undefined }, sessionId), isLoading && !isAgentRunning && _jsx(Loading, { isStreaming: !!streamingContent }), isAgentRunning && (_jsxs(Box, { paddingX: 1, children: [_jsxs(Text, { color: agentDryRun ? 'yellow' : '#f02a30', children: [agentDryRun ? '[DRY RUN]' : '[AGENT]', " Step ", agentIteration, " | ", agentActions.length, " actions"] }), _jsx(Text, { color: "gray", children: " | Press Esc to stop" })] }, "agent-status")), pendingFileChanges.length > 0 && !isLoading && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, marginY: 1, children: [_jsxs(Text, { color: "#f02a30", bold: true, children: ["\u2713 Detected ", pendingFileChanges.length, " file change(s):"] }), pendingFileChanges.map((change, i) => {
                         const actionColor = change.action === 'delete' ? 'red' : change.action === 'edit' ? 'yellow' : 'green';
                         const actionLabel = change.action === 'delete' ? 'DELETE' : change.action === 'edit' ? 'EDIT' : 'CREATE';
                         return (_jsxs(Text, { children: ["\u2022 ", _jsxs(Text, { color: actionColor, children: ["[", actionLabel, "]"] }), " ", change.path, change.action !== 'delete' && change.content.includes('\n') && ` (${change.content.split('\n').length} lines)`] }, i));

package/dist/components/AgentProgress.d.ts

@@ -14,12 +14,12 @@ interface AgentProgressProps {
 }
 export declare const AgentProgress: React.FC<AgentProgressProps>;
 /**
- * Live Code Stream component - shows current file operation with live preview
+ * Live Statistics component - shows real-time agent progress
  *
- * KEY DESIGN: This component always renders exactly MAX_LINES lines
- * - While running: shows live code preview
- * - When finished: shows summary statistics
- * - This prevents ghost content and terminal jumping because height is constant
+ * KEY DESIGN: Always renders exactly FIXED_HEIGHT lines to prevent terminal jumping
+ * - While running: shows current action + live statistics
+ * - When finished: shows final summary (same height)
+ * - NEVER returns null - always renders the same box structure
  */
 interface LiveCodeStreamProps {
     actions: ActionLog[];

package/dist/components/AgentProgress.js

@@ -145,21 +145,17 @@ const isSectionBreak = (line, prevLine) => {
     }
     return false;
 };
-const MAX_PREVIEW_LINES = 12; // Code preview lines for live streaming
+const FIXED_HEIGHT = 6; // Fixed number of content lines (excluding border)
 export const LiveCodeStream = memo(({ actions, isRunning, terminalWidth = 80 }) => {
-    // Find the current write/edit action for live preview (skip read actions)
     const currentAction = actions.length > 0 ? actions[actions.length - 1] : null;
-    const isCodeAction = currentAction && (currentAction.type === 'write' || currentAction.type === 'edit');
-    // Skip rendering for read actions - no preview needed
-    const isReadAction = currentAction && currentAction.type === 'read';
-    // ALL HOOKS MUST BE CALLED BEFORE ANY EARLY RETURNS (Rules of Hooks)
     // Calculate statistics from all actions
     const stats = useMemo(() => {
         const filesCreated = actions.filter(a => a.type === 'write' && a.result === 'success');
         const filesEdited = actions.filter(a => a.type === 'edit' && a.result === 'success');
         const filesDeleted = actions.filter(a => a.type === 'delete' && a.result === 'success');
-        const filesRead = actions.filter(a => a.type === 'read' && a.result === 'success');
-        const commands = actions.filter(a => a.type === 'command' && a.result === 'success');
+        const filesRead = actions.filter(a => a.type === 'read');
+        const commands = actions.filter(a => a.type === 'command');
+        const searches = actions.filter(a => a.type === 'search');
         const errors = actions.filter(a => a.result === 'error');
         // Calculate total lines written
         let totalLinesWritten = 0;
@@ -174,55 +170,114 @@ export const LiveCodeStream = memo(({ actions, isRunning, terminalWidth = 80 })
             filesDeleted: filesDeleted.length,
             filesRead: filesRead.length,
             commands: commands.length,
+            searches: searches.length,
             errors: errors.length,
             totalLinesWritten,
-            createdFiles: filesCreated.map(a => a.target.split('/').pop() || a.target),
-            editedFiles: filesEdited.map(a => a.target.split('/').pop() || a.target),
+            totalActions: actions.length,
         };
     }, [actions]);
-    // Get code lines for preview
-    const codeLines = useMemo(() => {
-        if (!isCodeAction || !currentAction?.details)
-            return [];
-        return currentAction.details.split('\n');
-    }, [isCodeAction, currentAction?.details]);
-    // Don't render anything if no actions yet (agent just started)
-    if (actions.length === 0) {
-        return null;
-    }
-    const filename = currentAction?.target.split('/').pop() || '';
-    const ext = getFileExtension(filename);
-    const langLabel = getLanguageLabel(ext);
-    // RUNNING STATE: Show live code preview
-    if (isRunning && isCodeAction && codeLines.length > 0) {
-        // Show last N lines of code being written
-        const visibleLines = codeLines.slice(-MAX_PREVIEW_LINES);
-        const hiddenCount = Math.max(0, codeLines.length - MAX_PREVIEW_LINES);
-        const actionIcon = currentAction.type === 'write' ? '+' : '~';
-        const actionColor = currentAction.type === 'write' ? 'green' : 'yellow';
-        const boxWidth = Math.min(terminalWidth - 4, 76);
-        return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: actionColor, marginBottom: 1, width: boxWidth, children: [_jsxs(Box, { paddingX: 1, children: [_jsxs(Text, { color: actionColor, bold: true, children: [actionIcon, " "] }), _jsx(Text, { color: "white", bold: true, children: filename }), _jsxs(Text, { color: "gray", children: [" \u2022 ", langLabel, " \u2022 ", codeLines.length, " lines"] })] }), _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [hiddenCount > 0 && (_jsxs(Text, { color: "gray", dimColor: true, children: ["  ... ", hiddenCount, " more lines above"] })), visibleLines.map((line, i) => {
-                            const lineNum = hiddenCount + i + 1;
-                            const displayLine = line.length > boxWidth - 10
-                                ? line.slice(0, boxWidth - 13) + '...'
-                                : line;
-                            return (_jsxs(Text, { children: [_jsxs(Text, { color: "gray", dimColor: true, children: [String(lineNum).padStart(3), " "] }), _jsx(Text, { color: getCodeColor(line, ext), children: displayLine || ' ' })] }, i));
-                        })] })] }));
+    const boxWidth = Math.min(terminalWidth - 4, 60);
+    // Build content lines array - always exactly FIXED_HEIGHT lines
+    const contentLines = [];
+    if (isRunning) {
+        // Line 1: Current action
+        if (currentAction) {
+            contentLines.push(_jsxs(Box, { children: [_jsxs(Text, { color: getActionColor(currentAction.type), bold: true, children: [getActionLabel(currentAction.type), " "] }), _jsx(Text, { color: "white", children: formatTarget(currentAction.target, boxWidth - 15) })] }, "current"));
+        }
+        else {
+            contentLines.push(_jsx(Text, { color: "gray", children: "Starting..." }, "current"));
+        }
+        // Line 2: Separator
+        contentLines.push(_jsx(Text, { color: "gray", dimColor: true, children: '─'.repeat(boxWidth - 4) }, "sep"));
+        // Line 3: File changes stats
+        const changesParts = [];
+        if (stats.filesCreated > 0)
+            changesParts.push(`+${stats.filesCreated} created`);
+        if (stats.filesEdited > 0)
+            changesParts.push(`~${stats.filesEdited} edited`);
+        if (stats.filesDeleted > 0)
+            changesParts.push(`-${stats.filesDeleted} deleted`);
+        if (changesParts.length > 0) {
+            contentLines.push(_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "Files: " }), _jsx(Text, { color: "green", children: changesParts.join(' ') })] }, "changes"));
+        }
+        else {
+            contentLines.push(_jsx(Text, { color: "gray", dimColor: true, children: "Files: no changes yet" }, "changes"));
+        }
+        // Line 4: Other stats
+        const otherParts = [];
+        if (stats.filesRead > 0)
+            otherParts.push(`${stats.filesRead}R`);
+        if (stats.commands > 0)
+            otherParts.push(`${stats.commands}C`);
+        if (stats.searches > 0)
+            otherParts.push(`${stats.searches}S`);
+        if (stats.totalLinesWritten > 0)
+            otherParts.push(`${stats.totalLinesWritten}L`);
+        contentLines.push(_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "Stats: " }), _jsx(Text, { color: "gray", children: otherParts.length > 0 ? otherParts.join(' | ') : 'gathering...' })] }, "other"));
+        // Line 5: Errors if any
+        if (stats.errors > 0) {
+            contentLines.push(_jsxs(Text, { color: "red", children: [stats.errors, " error(s)"] }, "errors"));
+        }
+        else {
+            contentLines.push(_jsx(Text, { color: "gray", dimColor: true, children: " " }, "errors"));
+        }
+        // Line 6: Help text
+        contentLines.push(_jsx(Text, { color: "gray", dimColor: true, children: "Press Esc to stop" }, "help"));
     }
-    // RUNNING STATE but not a code action (and not read): show simple status
-    // Skip showing box for read actions - they don't need preview
-    if (isRunning && currentAction && !isReadAction) {
-        const boxWidth = Math.min(terminalWidth - 4, 76);
-        return (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", marginBottom: 1, width: boxWidth, children: _jsxs(Box, { paddingX: 1, children: [_jsx(Text, { color: "cyan", bold: true, children: "\u25E6 " }), _jsxs(Text, { color: getActionColor(currentAction.type), children: [getActionLabel(currentAction.type), " "] }), _jsx(Text, { color: "white", children: formatTarget(currentAction.target) })] }) }));
+    else {
+        // FINISHED STATE
+        // Line 1: Complete header
+        contentLines.push(_jsxs(Text, { color: stats.errors > 0 ? 'red' : 'green', bold: true, children: [stats.errors > 0 ? 'Completed with errors' : 'Completed', " (", stats.totalActions, " actions)"] }, "header"));
+        // Line 2: Separator  
+        contentLines.push(_jsx(Text, { color: "gray", dimColor: true, children: '─'.repeat(boxWidth - 4) }, "sep"));
+        // Line 3: File changes
+        const changesParts = [];
+        if (stats.filesCreated > 0)
+            changesParts.push(`+${stats.filesCreated} created`);
+        if (stats.filesEdited > 0)
+            changesParts.push(`~${stats.filesEdited} edited`);
+        if (stats.filesDeleted > 0)
+            changesParts.push(`-${stats.filesDeleted} deleted`);
+        if (changesParts.length > 0) {
+            contentLines.push(_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "Files: " }), _jsx(Text, { color: "green", children: changesParts.join(' ') })] }, "changes"));
+        }
+        else {
+            contentLines.push(_jsx(Text, { color: "gray", children: "Files: no changes made" }, "changes"));
+        }
+        // Line 4: Lines written
+        if (stats.totalLinesWritten > 0) {
+            contentLines.push(_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: "Lines: " }), _jsxs(Text, { color: "white", children: [stats.totalLinesWritten, " written"] })] }, "lines"));
+        }
+        else {
+            contentLines.push(_jsx(Text, { color: "gray", dimColor: true, children: " " }, "lines"));
+        }
+        // Line 5: Other stats
+        const otherParts = [];
+        if (stats.filesRead > 0)
+            otherParts.push(`${stats.filesRead} read`);
+        if (stats.commands > 0)
+            otherParts.push(`${stats.commands} commands`);
+        if (stats.searches > 0)
+            otherParts.push(`${stats.searches} searches`);
+        if (otherParts.length > 0) {
+            contentLines.push(_jsxs(Text, { color: "gray", dimColor: true, children: ["Also: ", otherParts.join(', ')] }, "other"));
+        }
+        else {
+            contentLines.push(_jsx(Text, { color: "gray", dimColor: true, children: " " }, "other"));
+        }
+        // Line 6: Errors
+        if (stats.errors > 0) {
+            contentLines.push(_jsxs(Text, { color: "red", children: [stats.errors, " error(s) occurred"] }, "errors"));
+        }
+        else {
+            contentLines.push(_jsx(Text, { color: "gray", dimColor: true, children: " " }, "errors"));
+        }
     }
-    // For read actions while running, don't show anything
-    if (isRunning && isReadAction) {
-        return null;
+    // Pad to fixed height if needed
+    while (contentLines.length < FIXED_HEIGHT) {
+        contentLines.push(_jsx(Text, { color: "gray", dimColor: true, children: " " }, `pad-${contentLines.length}`));
     }
-    // FINISHED STATE: Show summary statistics (same height as live preview)
-    const boxWidth = Math.min(terminalWidth - 4, 76);
-    const hasChanges = stats.filesCreated > 0 || stats.filesEdited > 0 || stats.filesDeleted > 0;
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: stats.errors > 0 ? 'red' : 'green', marginBottom: 1, width: boxWidth, children: [_jsxs(Box, { paddingX: 1, children: [_jsxs(Text, { color: stats.errors > 0 ? 'red' : 'green', bold: true, children: [stats.errors > 0 ? '!' : '✓', " Session Complete"] }), _jsxs(Text, { color: "gray", children: [" \u2022 ", actions.length, " actions"] })] }), _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [hasChanges ? (_jsxs(_Fragment, { children: [stats.filesCreated > 0 && (_jsxs(Text, { children: [_jsxs(Text, { color: "green", bold: true, children: ["  + ", stats.filesCreated, " "] }), _jsx(Text, { color: "gray", children: "file(s) created" }), stats.createdFiles.length <= 3 && (_jsxs(Text, { color: "gray", dimColor: true, children: [" (", stats.createdFiles.join(', '), ")"] }))] })), stats.filesEdited > 0 && (_jsxs(Text, { children: [_jsxs(Text, { color: "yellow", bold: true, children: ["  ~ ", stats.filesEdited, " "] }), _jsx(Text, { color: "gray", children: "file(s) modified" }), stats.editedFiles.length <= 3 && (_jsxs(Text, { color: "gray", dimColor: true, children: [" (", stats.editedFiles.join(', '), ")"] }))] })), stats.filesDeleted > 0 && (_jsxs(Text, { children: [_jsxs(Text, { color: "red", bold: true, children: ["  - ", stats.filesDeleted, " "] }), _jsx(Text, { color: "gray", children: "file(s) deleted" })] })), stats.totalLinesWritten > 0 && (_jsxs(Text, { children: [_jsxs(Text, { color: "cyan", bold: true, children: ["  \u2261 ", stats.totalLinesWritten, " "] }), _jsx(Text, { color: "gray", children: "total lines written" })] })), stats.filesRead > 0 && (_jsxs(Text, { color: "gray", dimColor: true, children: ["    ", stats.filesRead, " file(s) read"] })), stats.commands > 0 && (_jsxs(Text, { color: "gray", dimColor: true, children: ["    ", stats.commands, " command(s) run"] }))] })) : (_jsxs(_Fragment, { children: [_jsx(Text, { color: "gray", children: "  No file changes made" }), stats.filesRead > 0 && (_jsxs(Text, { color: "gray", dimColor: true, children: ["    ", stats.filesRead, " file(s) read"] })), stats.commands > 0 && (_jsxs(Text, { color: "gray", dimColor: true, children: ["    ", stats.commands, " command(s) run"] }))] })), stats.errors > 0 && (_jsxs(Text, { color: "red", children: ["  \u2717 ", stats.errors, " error(s) occurred"] })), Array.from({ length: Math.max(0, MAX_PREVIEW_LINES - 6) }).map((_, i) => (_jsx(Text, { color: "gray", dimColor: true, children: " " }, `pad-${i}`)))] })] }));
+    return (_jsx(Box, { flexDirection: "column", borderStyle: "round", borderColor: isRunning ? 'cyan' : (stats.errors > 0 ? 'red' : 'green'), paddingX: 1, marginBottom: 1, width: boxWidth, children: contentLines }));
 });
 LiveCodeStream.displayName = 'LiveCodeStream';
 // Helper functions for action display
@@ -254,17 +309,18 @@ const getActionLabel = (type) => {
         default: return type.toUpperCase();
     }
 };
-const formatTarget = (target) => {
+const formatTarget = (target, maxLen = 50) => {
     // For file paths, show just the filename or last part
     if (target.includes('/')) {
         const parts = target.split('/');
         const filename = parts[parts.length - 1];
         if (parts.length > 2) {
-            return `.../${parts[parts.length - 2]}/${filename}`;
+            const short = `.../${parts[parts.length - 2]}/${filename}`;
+            return short.length > maxLen ? '...' + short.slice(-(maxLen - 3)) : short;
         }
-        return target.length > 50 ? '...' + target.slice(-47) : target;
+        return target.length > maxLen ? '...' + target.slice(-(maxLen - 3)) : target;
     }
-    return target.length > 50 ? target.slice(0, 47) + '...' : target;
+    return target.length > maxLen ? target.slice(0, maxLen - 3) + '...' : target;
 };
 /**
  * Single action item display

package/dist/components/MessageList.d.ts

@@ -3,6 +3,7 @@ import { Message } from '../config/index';
 interface MessageListProps {
     messages: Message[];
     streamingContent?: string;
+    agentStreamingContent?: string;
     scrollOffset?: number;
     terminalHeight?: number;
 }

package/dist/components/MessageList.js

@@ -21,9 +21,9 @@ MemoizedMessage.displayName = 'MemoizedMessage';
  * NOTE: This is a temporary solution until we implement a custom renderer
  * like Claude CLI uses (DEC Mode 2026 / synchronized output).
  */
-export const MessageList = memo(({ messages, streamingContent, }) => {
+export const MessageList = memo(({ messages, streamingContent, agentStreamingContent, }) => {
     // Memoize the messages array rendering
     const renderedMessages = useMemo(() => (messages.map((msg, index) => (_jsx(MemoizedMessage, { msg: msg, index: index }, `msg-${index}-${msg.role}`)))), [messages]);
-    return (_jsxs(Box, { flexDirection: "column", children: [renderedMessages, streamingContent && (_jsx(StreamingMessage, { content: streamingContent }))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [renderedMessages, streamingContent && (_jsx(StreamingMessage, { content: streamingContent })), agentStreamingContent && (_jsx(StreamingMessage, { content: `**Agent Actions:**\n${agentStreamingContent}` }))] }));
 });
 MessageList.displayName = 'MessageList';

package/dist/components/ProjectPermission.js

@@ -1,16 +1,29 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { useState } from 'react';
 import { Box, Text, useInput } from 'ink';
-import { setProjectPermission } from '../config/index.js';
+import { setProjectPermission, hasStandardProjectMarkers, initializeAsProject } from '../config/index.js';
 import { getProjectSummary } from '../utils/project.js';
 export const ProjectPermission = ({ projectPath, onComplete }) => {
-    const [step, setStep] = useState('read');
+    // If folder doesn't have standard project markers, ask if user wants to initialize it
+    const isStandardProject = hasStandardProjectMarkers(projectPath);
+    const [step, setStep] = useState(isStandardProject ? 'read' : 'init');
     const [readGranted, setReadGranted] = useState(false);
     const summary = getProjectSummary(projectPath);
     const projectName = summary?.name || projectPath.split('/').pop() || 'Unknown';
     useInput((input, key) => {
         const char = input.toLowerCase();
-        if (step === 'read') {
+        if (step === 'init') {
+            if (char === 'y') {
+                // Initialize as project and continue to permissions
+                initializeAsProject(projectPath);
+                setStep('read');
+            }
+            else if (char === 'n' || key.escape) {
+                // Don't initialize - use global config, skip to read permission
+                setStep('read');
+            }
+        }
+        else if (step === 'read') {
             if (char === 'y') {
                 // Grant for this session only
                 setReadGranted(true);
@@ -48,5 +61,5 @@ export const ProjectPermission = ({ projectPath, onComplete }) => {
             }
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, children: [_jsx(Text, { color: "#f02a30", bold: true, children: "Project Access Request" }), _jsx(Text, { children: " " }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { children: "Project: " }), _jsx(Text, { color: "cyan", bold: true, children: projectName })] }), _jsxs(Text, { children: [_jsx(Text, { children: "Path: " }), _jsx(Text, { children: projectPath })] }), summary && (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { children: "Type: " }), _jsx(Text, { children: summary.type })] }), _jsxs(Text, { children: [_jsx(Text, { children: "Files: " }), _jsxs(Text, { children: [summary.fileCount, " code files"] })] })] }))] }), _jsx(Text, { children: " " }), step === 'read' && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "#f02a30", children: "Allow Codeep to read project files?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: "This enables:" }), _jsx(Text, { children: "  \u2022 Auto-detect file paths in your messages" }), _jsx(Text, { children: "  \u2022 Send file contents to AI for analysis" }), _jsx(Text, { children: "  \u2022 Project structure awareness" }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { color: "green", children: "[Y]" }), _jsx(Text, { children: " Yes (this session)   " }), _jsx(Text, { color: "cyan", children: "[A]" }), _jsx(Text, { children: " Always   " }), _jsx(Text, { color: "#f02a30", children: "[N]" }), _jsx(Text, { children: " No" })] })] })), step === 'write' && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "green", children: "\u2713 Read permission granted" }), _jsx(Text, { children: " " }), _jsx(Text, { color: "#f02a30", children: "Allow Codeep to suggest file changes?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: "This enables:" }), _jsx(Text, { children: "  \u2022 AI can suggest code modifications" }), _jsx(Text, { children: "  \u2022 You'll always see changes before applying" }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { color: "green", children: "[Y]" }), _jsx(Text, { children: " Yes (this session)   " }), _jsx(Text, { color: "cyan", children: "[A]" }), _jsx(Text, { children: " Always   " }), _jsx(Text, { color: "#f02a30", children: "[N]" }), _jsx(Text, { children: " Read-only" })] })] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, children: [_jsx(Text, { color: "#f02a30", bold: true, children: "Project Access Request" }), _jsx(Text, { children: " " }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { children: [_jsx(Text, { children: "Project: " }), _jsx(Text, { color: "cyan", bold: true, children: projectName })] }), _jsxs(Text, { children: [_jsx(Text, { children: "Path: " }), _jsx(Text, { children: projectPath })] }), summary && (_jsxs(_Fragment, { children: [_jsxs(Text, { children: [_jsx(Text, { children: "Type: " }), _jsx(Text, { children: summary.type })] }), _jsxs(Text, { children: [_jsx(Text, { children: "Files: " }), _jsxs(Text, { children: [summary.fileCount, " code files"] })] })] }))] }), _jsx(Text, { children: " " }), step === 'init' && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "yellow", children: "This folder is not recognized as a project." }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Initialize as a Codeep project?" }), _jsx(Text, { children: " " }), _jsx(Text, { color: "gray", children: "This will create a .codeep/ folder to store:" }), _jsx(Text, { color: "gray", children: "  \u2022 Session history" }), _jsx(Text, { color: "gray", children: "  \u2022 Project-specific settings" }), _jsx(Text, { color: "gray", children: "  \u2022 Permission preferences" }), _jsx(Text, { children: " " }), _jsx(Text, { color: "gray", children: "If you choose No, settings will be stored globally." }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { color: "green", children: "[Y]" }), _jsx(Text, { children: " Yes, initialize   " }), _jsx(Text, { color: "cyan", children: "[N]" }), _jsx(Text, { children: " No, use global config" })] })] })), step === 'read' && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "#f02a30", children: "Allow Codeep to read project files?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: "This enables:" }), _jsx(Text, { children: "  \u2022 Auto-detect file paths in your messages" }), _jsx(Text, { children: "  \u2022 Send file contents to AI for analysis" }), _jsx(Text, { children: "  \u2022 Project structure awareness" }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { color: "green", children: "[Y]" }), _jsx(Text, { children: " Yes (this session)   " }), _jsx(Text, { color: "cyan", children: "[A]" }), _jsx(Text, { children: " Always   " }), _jsx(Text, { color: "#f02a30", children: "[N]" }), _jsx(Text, { children: " No" })] })] })), step === 'write' && (_jsxs(_Fragment, { children: [_jsx(Text, { color: "green", children: "\u2713 Read permission granted" }), _jsx(Text, { children: " " }), _jsx(Text, { color: "#f02a30", children: "Allow Codeep to suggest file changes?" }), _jsx(Text, { children: " " }), _jsx(Text, { children: "This enables:" }), _jsx(Text, { children: "  \u2022 AI can suggest code modifications" }), _jsx(Text, { children: "  \u2022 You'll always see changes before applying" }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { color: "green", children: "[Y]" }), _jsx(Text, { children: " Yes (this session)   " }), _jsx(Text, { color: "cyan", children: "[A]" }), _jsx(Text, { children: " Always   " }), _jsx(Text, { color: "#f02a30", children: "[N]" }), _jsx(Text, { children: " Read-only" })] })] }))] }));
 };

package/dist/config/index.d.ts

@@ -43,6 +43,19 @@ interface ConfigSchema {
 }
 export type { AgentMode };
 export type { LanguageCode };
+/**
+ * Check if directory has standard project markers (not manually initialized)
+ */
+export declare function hasStandardProjectMarkers(path: string): boolean;
+/**
+ * Initialize a folder as a Codeep project
+ * Creates .codeep/project.json marker file
+ */
+export declare function initializeAsProject(path: string): boolean;
+/**
+ * Check if folder was manually initialized as project
+ */
+export declare function isManuallyInitializedProject(path: string): boolean;
 export declare const config: Conf<ConfigSchema>;
 export declare const LANGUAGES: Record<string, string>;
 export declare const PROTOCOLS: Record<string, string>;

package/dist/config/index.js

@@ -32,8 +32,14 @@ function getLocalConfigPath(projectPath) {
 /**
  * Check if directory is a project
  * Looks for common project indicators: package.json, pyproject.toml, Cargo.toml, go.mod, composer.json, etc.
+ * Also checks if user has manually initialized this folder as a project (.codeep/project.json)
  */
 function isProjectDirectory(path) {
+    // Check if user has manually initialized this as a project
+    const manualProjectMarker = join(path, '.codeep', 'project.json');
+    if (existsSync(manualProjectMarker)) {
+        return true;
+    }
     const projectFiles = [
         'package.json', // Node.js
         'pyproject.toml', // Python (Poetry)
@@ -48,6 +54,53 @@ function isProjectDirectory(path) {
     ];
     return projectFiles.some(file => existsSync(join(path, file)));
 }
+/**
+ * Check if directory has standard project markers (not manually initialized)
+ */
+export function hasStandardProjectMarkers(path) {
+    const projectFiles = [
+        'package.json',
+        'pyproject.toml',
+        'requirements.txt',
+        'setup.py',
+        'Cargo.toml',
+        'go.mod',
+        'composer.json',
+        'pom.xml',
+        'build.gradle',
+        '.git',
+    ];
+    return projectFiles.some(file => existsSync(join(path, file)));
+}
+/**
+ * Initialize a folder as a Codeep project
+ * Creates .codeep/project.json marker file
+ */
+export function initializeAsProject(path) {
+    try {
+        const codeepDir = join(path, '.codeep');
+        if (!existsSync(codeepDir)) {
+            mkdirSync(codeepDir, { recursive: true });
+        }
+        const projectFile = join(codeepDir, 'project.json');
+        const projectData = {
+            name: path.split('/').pop() || 'project',
+            initializedAt: new Date().toISOString(),
+            version: '1.0',
+        };
+        writeFileSync(projectFile, JSON.stringify(projectData, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if folder was manually initialized as project
+ */
+export function isManuallyInitializedProject(path) {
+    return existsSync(join(path, '.codeep', 'project.json'));
+}
 /**
  * Get fallback config directory if standard location is not writable
  * Falls back to .codeep in current working directory

package/dist/utils/projectIntelligence.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Project Intelligence - Deep project analysis and caching
+ * Scans project once and caches important information for faster AI context
+ */
+export interface ProjectIntelligence {
+    version: string;
+    scannedAt: string;
+    projectPath: string;
+    name: string;
+    type: string;
+    description: string;
+    structure: {
+        totalFiles: number;
+        totalDirectories: number;
+        languages: Record<string, number>;
+        topDirectories: string[];
+    };
+    dependencies: {
+        runtime: string[];
+        dev: string[];
+        frameworks: string[];
+    };
+    keyFiles: {
+        path: string;
+        summary: string;
+    }[];
+    entryPoints: string[];
+    scripts: Record<string, string>;
+    architecture: {
+        patterns: string[];
+        mainModules: string[];
+        apiEndpoints?: string[];
+        components?: string[];
+    };
+    conventions: {
+        indentation: 'tabs' | 'spaces' | 'mixed';
+        quotes: 'single' | 'double' | 'mixed';
+        semicolons: boolean;
+        namingStyle: 'camelCase' | 'snake_case' | 'PascalCase' | 'mixed';
+    };
+    testing: {
+        framework: string | null;
+        testDirectory: string | null;
+        hasTests: boolean;
+    };
+    notes: string[];
+}
+/**
+ * Scan project and generate intelligence
+ */
+export declare function scanProject(projectPath: string): Promise<ProjectIntelligence>;
+/**
+ * Save intelligence to .codeep/intelligence.json
+ */
+export declare function saveProjectIntelligence(projectPath: string, intelligence: ProjectIntelligence): boolean;
+/**
+ * Load intelligence from .codeep/intelligence.json
+ */
+export declare function loadProjectIntelligence(projectPath: string): ProjectIntelligence | null;
+/**
+ * Check if intelligence exists and is fresh (less than 24 hours old)
+ */
+export declare function isIntelligenceFresh(projectPath: string, maxAgeHours?: number): boolean;
+/**
+ * Generate AI-friendly context from intelligence
+ */
+export declare function generateContextFromIntelligence(intelligence: ProjectIntelligence): string;

package/dist/utils/projectIntelligence.js

@@ -0,0 +1,601 @@
+/**
+ * Project Intelligence - Deep project analysis and caching
+ * Scans project once and caches important information for faster AI context
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, readdirSync } from 'fs';
+import { join, basename, extname } from 'path';
+// ============================================================================
+// Constants
+// ============================================================================
+const INTELLIGENCE_VERSION = '1.0';
+const INTELLIGENCE_FILE = 'intelligence.json';
+const IGNORE_DIRS = new Set([
+    'node_modules', '.git', 'dist', 'build', '.next', 'coverage',
+    '.cache', '.vscode', '.idea', '__pycache__', 'venv', '.env',
+    'vendor', 'target', 'out', 'bin', 'obj', '.nuxt', '.output',
+]);
+const LANGUAGE_MAP = {
+    '.ts': 'TypeScript', '.tsx': 'TypeScript React',
+    '.js': 'JavaScript', '.jsx': 'JavaScript React',
+    '.py': 'Python', '.rb': 'Ruby', '.go': 'Go', '.rs': 'Rust',
+    '.java': 'Java', '.kt': 'Kotlin', '.swift': 'Swift',
+    '.php': 'PHP', '.cs': 'C#', '.cpp': 'C++', '.c': 'C',
+    '.vue': 'Vue', '.svelte': 'Svelte',
+    '.css': 'CSS', '.scss': 'SCSS', '.less': 'Less',
+    '.html': 'HTML', '.json': 'JSON', '.yaml': 'YAML', '.yml': 'YAML',
+    '.md': 'Markdown', '.sql': 'SQL', '.sh': 'Shell',
+};
+const FRAMEWORK_INDICATORS = {
+    'React': ['react', 'react-dom'],
+    'Next.js': ['next'],
+    'Vue': ['vue'],
+    'Nuxt': ['nuxt'],
+    'Angular': ['@angular/core'],
+    'Svelte': ['svelte'],
+    'Express': ['express'],
+    'Fastify': ['fastify'],
+    'NestJS': ['@nestjs/core'],
+    'Django': ['django'],
+    'Flask': ['flask'],
+    'FastAPI': ['fastapi'],
+    'Rails': ['rails'],
+    'Laravel': ['laravel'],
+    'Spring': ['spring-boot'],
+};
+// ============================================================================
+// Main Functions
+// ============================================================================
+/**
+ * Scan project and generate intelligence
+ */
+export async function scanProject(projectPath) {
+    const intelligence = {
+        version: INTELLIGENCE_VERSION,
+        scannedAt: new Date().toISOString(),
+        projectPath,
+        name: basename(projectPath),
+        type: 'Unknown',
+        description: '',
+        structure: {
+            totalFiles: 0,
+            totalDirectories: 0,
+            languages: {},
+            topDirectories: [],
+        },
+        dependencies: {
+            runtime: [],
+            dev: [],
+            frameworks: [],
+        },
+        keyFiles: [],
+        entryPoints: [],
+        scripts: {},
+        architecture: {
+            patterns: [],
+            mainModules: [],
+        },
+        conventions: {
+            indentation: 'spaces',
+            quotes: 'single',
+            semicolons: true,
+            namingStyle: 'camelCase',
+        },
+        testing: {
+            framework: null,
+            testDirectory: null,
+            hasTests: false,
+        },
+        notes: [],
+    };
+    // Scan directory structure
+    scanDirectoryStructure(projectPath, intelligence);
+    // Detect project type and dependencies
+    detectProjectType(projectPath, intelligence);
+    // Analyze key files
+    analyzeKeyFiles(projectPath, intelligence);
+    // Detect architecture patterns
+    detectArchitecture(projectPath, intelligence);
+    // Analyze code conventions
+    analyzeConventions(projectPath, intelligence);
+    // Detect testing setup
+    detectTesting(projectPath, intelligence);
+    return intelligence;
+}
+/**
+ * Save intelligence to .codeep/intelligence.json
+ */
+export function saveProjectIntelligence(projectPath, intelligence) {
+    try {
+        const codeepDir = join(projectPath, '.codeep');
+        if (!existsSync(codeepDir)) {
+            mkdirSync(codeepDir, { recursive: true });
+        }
+        const filePath = join(codeepDir, INTELLIGENCE_FILE);
+        writeFileSync(filePath, JSON.stringify(intelligence, null, 2));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load intelligence from .codeep/intelligence.json
+ */
+export function loadProjectIntelligence(projectPath) {
+    try {
+        const filePath = join(projectPath, '.codeep', INTELLIGENCE_FILE);
+        if (!existsSync(filePath))
+            return null;
+        const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check if intelligence exists and is fresh (less than 24 hours old)
+ */
+export function isIntelligenceFresh(projectPath, maxAgeHours = 24) {
+    const intelligence = loadProjectIntelligence(projectPath);
+    if (!intelligence)
+        return false;
+    const scannedAt = new Date(intelligence.scannedAt).getTime();
+    const now = Date.now();
+    const ageHours = (now - scannedAt) / (1000 * 60 * 60);
+    return ageHours < maxAgeHours;
+}
+/**
+ * Generate AI-friendly context from intelligence
+ */
+export function generateContextFromIntelligence(intelligence) {
+    const lines = [];
+    lines.push(`# Project: ${intelligence.name}`);
+    lines.push(`Type: ${intelligence.type}`);
+    if (intelligence.description) {
+        lines.push(`Description: ${intelligence.description}`);
+    }
+    lines.push('');
+    // Structure
+    lines.push('## Structure');
+    lines.push(`- ${intelligence.structure.totalFiles} files, ${intelligence.structure.totalDirectories} directories`);
+    const topLangs = Object.entries(intelligence.structure.languages)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([ext, count]) => `${LANGUAGE_MAP[ext] || ext} (${count})`)
+        .join(', ');
+    if (topLangs) {
+        lines.push(`- Languages: ${topLangs}`);
+    }
+    if (intelligence.structure.topDirectories.length > 0) {
+        lines.push(`- Main directories: ${intelligence.structure.topDirectories.join(', ')}`);
+    }
+    lines.push('');
+    // Frameworks
+    if (intelligence.dependencies.frameworks.length > 0) {
+        lines.push('## Frameworks');
+        lines.push(intelligence.dependencies.frameworks.join(', '));
+        lines.push('');
+    }
+    // Architecture
+    if (intelligence.architecture.patterns.length > 0 || intelligence.architecture.mainModules.length > 0) {
+        lines.push('## Architecture');
+        if (intelligence.architecture.patterns.length > 0) {
+            lines.push(`Patterns: ${intelligence.architecture.patterns.join(', ')}`);
+        }
+        if (intelligence.architecture.mainModules.length > 0) {
+            lines.push(`Main modules: ${intelligence.architecture.mainModules.join(', ')}`);
+        }
+        lines.push('');
+    }
+    // Entry points
+    if (intelligence.entryPoints.length > 0) {
+        lines.push('## Entry Points');
+        intelligence.entryPoints.forEach(ep => lines.push(`- ${ep}`));
+        lines.push('');
+    }
+    // Scripts
+    if (Object.keys(intelligence.scripts).length > 0) {
+        lines.push('## Available Scripts');
+        Object.entries(intelligence.scripts).slice(0, 10).forEach(([name, cmd]) => {
+            lines.push(`- ${name}: ${cmd}`);
+        });
+        lines.push('');
+    }
+    // Key files
+    if (intelligence.keyFiles.length > 0) {
+        lines.push('## Key Files');
+        intelligence.keyFiles.forEach(kf => {
+            lines.push(`- ${kf.path}: ${kf.summary}`);
+        });
+        lines.push('');
+    }
+    // Testing
+    if (intelligence.testing.hasTests) {
+        lines.push('## Testing');
+        lines.push(`Framework: ${intelligence.testing.framework || 'Unknown'}`);
+        if (intelligence.testing.testDirectory) {
+            lines.push(`Test directory: ${intelligence.testing.testDirectory}`);
+        }
+        lines.push('');
+    }
+    // Conventions
+    lines.push('## Code Conventions');
+    lines.push(`- Indentation: ${intelligence.conventions.indentation}`);
+    lines.push(`- Quotes: ${intelligence.conventions.quotes}`);
+    lines.push(`- Semicolons: ${intelligence.conventions.semicolons ? 'yes' : 'no'}`);
+    lines.push(`- Naming: ${intelligence.conventions.namingStyle}`);
+    // Notes
+    if (intelligence.notes.length > 0) {
+        lines.push('');
+        lines.push('## Notes');
+        intelligence.notes.forEach(note => lines.push(`- ${note}`));
+    }
+    return lines.join('\n');
+}
+// ============================================================================
+// Helper Functions
+// ============================================================================
+function scanDirectoryStructure(dir, intelligence, depth = 0) {
+    if (depth > 5)
+        return; // Max depth
+    try {
+        const entries = readdirSync(dir);
+        for (const entry of entries) {
+            if (IGNORE_DIRS.has(entry))
+                continue;
+            if (entry.startsWith('.') && entry !== '.env.example')
+                continue;
+            const fullPath = join(dir, entry);
+            try {
+                const stat = statSync(fullPath);
+                if (stat.isDirectory()) {
+                    intelligence.structure.totalDirectories++;
+                    // Track top-level directories
+                    if (depth === 0) {
+                        intelligence.structure.topDirectories.push(entry);
+                    }
+                    scanDirectoryStructure(fullPath, intelligence, depth + 1);
+                }
+                else {
+                    intelligence.structure.totalFiles++;
+                    const ext = extname(entry).toLowerCase();
+                    if (ext) {
+                        intelligence.structure.languages[ext] = (intelligence.structure.languages[ext] || 0) + 1;
+                    }
+                }
+            }
+            catch {
+                // Skip inaccessible files
+            }
+        }
+    }
+    catch {
+        // Skip inaccessible directories
+    }
+}
+function detectProjectType(projectPath, intelligence) {
+    // Node.js / JavaScript
+    const packageJsonPath = join(projectPath, 'package.json');
+    if (existsSync(packageJsonPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+            intelligence.name = pkg.name || intelligence.name;
+            intelligence.description = pkg.description || '';
+            // Detect type
+            if (existsSync(join(projectPath, 'tsconfig.json'))) {
+                intelligence.type = 'TypeScript/Node.js';
+            }
+            else {
+                intelligence.type = 'JavaScript/Node.js';
+            }
+            // Dependencies
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            intelligence.dependencies.runtime = Object.keys(pkg.dependencies || {});
+            intelligence.dependencies.dev = Object.keys(pkg.devDependencies || {});
+            // Detect frameworks
+            for (const [framework, indicators] of Object.entries(FRAMEWORK_INDICATORS)) {
+                if (indicators.some(ind => allDeps[ind])) {
+                    intelligence.dependencies.frameworks.push(framework);
+                }
+            }
+            // Scripts
+            intelligence.scripts = pkg.scripts || {};
+            // Entry points
+            if (pkg.main)
+                intelligence.entryPoints.push(pkg.main);
+            if (pkg.module)
+                intelligence.entryPoints.push(pkg.module);
+            if (pkg.bin) {
+                if (typeof pkg.bin === 'string') {
+                    intelligence.entryPoints.push(pkg.bin);
+                }
+                else {
+                    intelligence.entryPoints.push(...Object.values(pkg.bin));
+                }
+            }
+            return;
+        }
+        catch {
+            // Invalid package.json
+        }
+    }
+    // Python
+    if (existsSync(join(projectPath, 'requirements.txt')) ||
+        existsSync(join(projectPath, 'pyproject.toml')) ||
+        existsSync(join(projectPath, 'setup.py'))) {
+        intelligence.type = 'Python';
+        // Try to read requirements
+        const reqPath = join(projectPath, 'requirements.txt');
+        if (existsSync(reqPath)) {
+            const content = readFileSync(reqPath, 'utf-8');
+            intelligence.dependencies.runtime = content
+                .split('\n')
+                .map(l => l.trim().split('==')[0].split('>=')[0])
+                .filter(l => l && !l.startsWith('#'));
+            // Detect frameworks
+            if (intelligence.dependencies.runtime.includes('django')) {
+                intelligence.dependencies.frameworks.push('Django');
+            }
+            if (intelligence.dependencies.runtime.includes('flask')) {
+                intelligence.dependencies.frameworks.push('Flask');
+            }
+            if (intelligence.dependencies.runtime.includes('fastapi')) {
+                intelligence.dependencies.frameworks.push('FastAPI');
+            }
+        }
+        return;
+    }
+    // Go
+    if (existsSync(join(projectPath, 'go.mod'))) {
+        intelligence.type = 'Go';
+        try {
+            const content = readFileSync(join(projectPath, 'go.mod'), 'utf-8');
+            const moduleMatch = content.match(/module\s+(\S+)/);
+            if (moduleMatch) {
+                intelligence.name = moduleMatch[1].split('/').pop() || intelligence.name;
+            }
+        }
+        catch { }
+        return;
+    }
+    // Rust
+    if (existsSync(join(projectPath, 'Cargo.toml'))) {
+        intelligence.type = 'Rust';
+        try {
+            const content = readFileSync(join(projectPath, 'Cargo.toml'), 'utf-8');
+            const nameMatch = content.match(/name\s*=\s*"([^"]+)"/);
+            if (nameMatch) {
+                intelligence.name = nameMatch[1];
+            }
+        }
+        catch { }
+        return;
+    }
+    // PHP
+    if (existsSync(join(projectPath, 'composer.json'))) {
+        intelligence.type = 'PHP';
+        try {
+            const composer = JSON.parse(readFileSync(join(projectPath, 'composer.json'), 'utf-8'));
+            intelligence.name = composer.name?.split('/').pop() || intelligence.name;
+            intelligence.description = composer.description || '';
+            if (composer.require?.['laravel/framework']) {
+                intelligence.dependencies.frameworks.push('Laravel');
+            }
+        }
+        catch { }
+        return;
+    }
+}
+function analyzeKeyFiles(projectPath, intelligence) {
+    const keyFilesToAnalyze = [
+        { path: 'README.md', summarize: summarizeReadme },
+        { path: 'readme.md', summarize: summarizeReadme },
+        { path: 'package.json', summarize: summarizePackageJson },
+        { path: 'tsconfig.json', summarize: summarizeTsConfig },
+        { path: 'Dockerfile', summarize: summarizeDockerfile },
+        { path: '.env.example', summarize: summarizeEnvExample },
+    ];
+    for (const { path, summarize } of keyFilesToAnalyze) {
+        const fullPath = join(projectPath, path);
+        if (existsSync(fullPath)) {
+            try {
+                const content = readFileSync(fullPath, 'utf-8');
+                const summary = summarize(content);
+                if (summary) {
+                    intelligence.keyFiles.push({ path, summary });
+                }
+            }
+            catch { }
+        }
+    }
+}
+function summarizeReadme(content) {
+    // Extract first meaningful paragraph
+    const lines = content.split('\n');
+    let inHeader = false;
+    for (const line of lines) {
+        if (line.startsWith('#')) {
+            inHeader = true;
+            continue;
+        }
+        if (inHeader && line.trim() && !line.startsWith('#') && !line.startsWith('-') && !line.startsWith('*')) {
+            return line.trim().slice(0, 150) + (line.length > 150 ? '...' : '');
+        }
+    }
+    return 'Project documentation';
+}
+function summarizePackageJson(content) {
+    try {
+        const pkg = JSON.parse(content);
+        const parts = [];
+        if (pkg.description)
+            parts.push(pkg.description);
+        if (pkg.version)
+            parts.push(`v${pkg.version}`);
+        return parts.join(' - ') || 'Node.js project configuration';
+    }
+    catch {
+        return 'Node.js project configuration';
+    }
+}
+function summarizeTsConfig(content) {
+    try {
+        const config = JSON.parse(content);
+        const target = config.compilerOptions?.target || 'unknown';
+        const module = config.compilerOptions?.module || 'unknown';
+        return `TypeScript config (target: ${target}, module: ${module})`;
+    }
+    catch {
+        return 'TypeScript configuration';
+    }
+}
+function summarizeDockerfile(_content) {
+    return 'Container configuration';
+}
+function summarizeEnvExample(content) {
+    const vars = content.split('\n').filter(l => l.includes('=') && !l.startsWith('#')).length;
+    return `${vars} environment variables`;
+}
+function detectArchitecture(projectPath, intelligence) {
+    const topDirs = intelligence.structure.topDirectories;
+    // Detect patterns based on directory structure
+    if (topDirs.includes('src')) {
+        intelligence.architecture.mainModules.push('src');
+    }
+    // MVC pattern
+    if (topDirs.includes('models') || topDirs.includes('views') || topDirs.includes('controllers')) {
+        intelligence.architecture.patterns.push('MVC');
+    }
+    // Component-based (React/Vue/etc)
+    if (topDirs.includes('components') || existsSync(join(projectPath, 'src', 'components'))) {
+        intelligence.architecture.patterns.push('Component-based');
+        intelligence.architecture.mainModules.push('components');
+    }
+    // API/Services pattern
+    if (topDirs.includes('api') || topDirs.includes('services') ||
+        existsSync(join(projectPath, 'src', 'api')) || existsSync(join(projectPath, 'src', 'services'))) {
+        intelligence.architecture.patterns.push('Service-oriented');
+    }
+    // Hooks (React)
+    if (topDirs.includes('hooks') || existsSync(join(projectPath, 'src', 'hooks'))) {
+        intelligence.architecture.mainModules.push('hooks');
+    }
+    // Utils/Helpers
+    if (topDirs.includes('utils') || topDirs.includes('helpers') || topDirs.includes('lib')) {
+        intelligence.architecture.mainModules.push('utils');
+    }
+    // Pages (Next.js, Nuxt, etc)
+    if (topDirs.includes('pages') || topDirs.includes('app')) {
+        intelligence.architecture.patterns.push('File-based routing');
+    }
+    // Detect API endpoints
+    const apiDir = join(projectPath, 'src', 'api');
+    const pagesApiDir = join(projectPath, 'pages', 'api');
+    const appApiDir = join(projectPath, 'app', 'api');
+    if (existsSync(apiDir) || existsSync(pagesApiDir) || existsSync(appApiDir)) {
+        intelligence.architecture.apiEndpoints = [];
+        // Could scan for route files here
+    }
+}
+function analyzeConventions(projectPath, intelligence) {
+    // Find a sample code file to analyze
+    const sampleExtensions = ['.ts', '.tsx', '.js', '.jsx'];
+    let sampleContent = null;
+    const srcDir = join(projectPath, 'src');
+    const searchDir = existsSync(srcDir) ? srcDir : projectPath;
+    try {
+        const files = readdirSync(searchDir);
+        for (const file of files) {
+            const ext = extname(file).toLowerCase();
+            if (sampleExtensions.includes(ext)) {
+                const content = readFileSync(join(searchDir, file), 'utf-8');
+                if (content.length > 100) {
+                    sampleContent = content;
+                    break;
+                }
+            }
+        }
+    }
+    catch { }
+    if (!sampleContent)
+        return;
+    // Analyze indentation
+    const tabCount = (sampleContent.match(/^\t/gm) || []).length;
+    const spaceCount = (sampleContent.match(/^  /gm) || []).length;
+    if (tabCount > spaceCount * 2) {
+        intelligence.conventions.indentation = 'tabs';
+    }
+    else if (spaceCount > tabCount * 2) {
+        intelligence.conventions.indentation = 'spaces';
+    }
+    else {
+        intelligence.conventions.indentation = 'mixed';
+    }
+    // Analyze quotes
+    const singleQuotes = (sampleContent.match(/'/g) || []).length;
+    const doubleQuotes = (sampleContent.match(/"/g) || []).length;
+    if (singleQuotes > doubleQuotes * 1.5) {
+        intelligence.conventions.quotes = 'single';
+    }
+    else if (doubleQuotes > singleQuotes * 1.5) {
+        intelligence.conventions.quotes = 'double';
+    }
+    else {
+        intelligence.conventions.quotes = 'mixed';
+    }
+    // Analyze semicolons
+    const semicolons = (sampleContent.match(/;\s*$/gm) || []).length;
+    const statements = (sampleContent.match(/\n/g) || []).length;
+    intelligence.conventions.semicolons = semicolons > statements * 0.3;
+    // Analyze naming
+    const camelCase = (sampleContent.match(/[a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*/g) || []).length;
+    const snakeCase = (sampleContent.match(/[a-z]+_[a-z]+/g) || []).length;
+    if (camelCase > snakeCase * 2) {
+        intelligence.conventions.namingStyle = 'camelCase';
+    }
+    else if (snakeCase > camelCase * 2) {
+        intelligence.conventions.namingStyle = 'snake_case';
+    }
+    else {
+        intelligence.conventions.namingStyle = 'mixed';
+    }
+}
+function detectTesting(projectPath, intelligence) {
+    // Check for test directories
+    const testDirs = ['test', 'tests', '__tests__', 'spec', 'specs'];
+    for (const dir of testDirs) {
+        if (existsSync(join(projectPath, dir))) {
+            intelligence.testing.hasTests = true;
+            intelligence.testing.testDirectory = dir;
+            break;
+        }
+    }
+    // Also check src/__tests__
+    if (existsSync(join(projectPath, 'src', '__tests__'))) {
+        intelligence.testing.hasTests = true;
+        intelligence.testing.testDirectory = 'src/__tests__';
+    }
+    // Detect framework from config files or dependencies
+    if (existsSync(join(projectPath, 'jest.config.js')) ||
+        existsSync(join(projectPath, 'jest.config.ts')) ||
+        intelligence.dependencies.dev.includes('jest')) {
+        intelligence.testing.framework = 'Jest';
+        intelligence.testing.hasTests = true;
+    }
+    else if (existsSync(join(projectPath, 'vitest.config.ts')) ||
+        existsSync(join(projectPath, 'vitest.config.js')) ||
+        intelligence.dependencies.dev.includes('vitest')) {
+        intelligence.testing.framework = 'Vitest';
+        intelligence.testing.hasTests = true;
+    }
+    else if (existsSync(join(projectPath, 'pytest.ini')) ||
+        existsSync(join(projectPath, 'pyproject.toml'))) {
+        intelligence.testing.framework = 'Pytest';
+        intelligence.testing.hasTests = true;
+    }
+    else if (intelligence.dependencies.dev.includes('mocha')) {
+        intelligence.testing.framework = 'Mocha';
+        intelligence.testing.hasTests = true;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.0.125",
+  "version": "1.0.127",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",