@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/utils/project-detection.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Project Detection Utilities
+ *
+ * Utilities for detecting project information from an existing directory.
+ * Used by the import project feature in /new wizard.
+ */
+export interface DetectedProject {
+    /** Project name from package.json or folder name */
+    name: string;
+    /** Prettified display name */
+    displayName: string;
+    /** Source of the name (package.json, go.mod, folder) */
+    nameSource: 'package.json' | 'go.mod' | 'pyproject.toml' | 'Cargo.toml' | 'folder';
+    /** Detected primary language (null if unknown) */
+    language: string | null;
+    /** Detected framework (null if not detected) */
+    framework: string | null;
+    /** Detected package manager (null if not detected) */
+    packageManager: string | null;
+    /** Whether .git directory exists */
+    hasGit: boolean;
+    /** Git remote URL (null if not configured) */
+    gitRemote: string | null;
+    /** Current git branch (null if not in git repo) */
+    gitBranch: string | null;
+    /** Whether COMPILR.md exists */
+    hasCompilrMd: boolean;
+    /** Whether CLAUDE.md exists (alternative) */
+    hasClaudeMd: boolean;
+}
+export interface GitInfo {
+    hasGit: boolean;
+    remote: string | null;
+    branch: string | null;
+}
+/**
+ * Detect project information from a directory path
+ */
+export declare function detectProjectInfo(projectPath: string): DetectedProject;
+/**
+ * Detect git repository information
+ */
+export declare function detectGitInfo(projectPath: string): GitInfo;
+/**
+ * Get a human-readable label for detected language
+ */
+export declare function getLanguageLabel(language: string | null): string;
+/**
+ * Get a human-readable label for detected framework
+ */
+export declare function getFrameworkLabel(framework: string | null): string;
+/**
+ * Check if a path is a valid directory that can be imported
+ */
+export declare function validateImportPath(importPath: string): {
+    valid: boolean;
+    error?: string;
+};

package/dist/utils/project-detection.js

@@ -0,0 +1,424 @@
+/**
+ * Project Detection Utilities
+ *
+ * Utilities for detecting project information from an existing directory.
+ * Used by the import project feature in /new wizard.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+const LANGUAGE_MARKERS = [
+    // Node.js / JavaScript / TypeScript
+    {
+        file: 'package.json',
+        language: 'node',
+        packageManager: 'npm', // Will be overridden if yarn.lock or pnpm-lock.yaml exists
+        frameworkDetector: (content) => {
+            try {
+                const pkg = JSON.parse(content);
+                const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                if (deps['next'])
+                    return 'next';
+                if (deps['nuxt'])
+                    return 'nuxt';
+                if (deps['react'])
+                    return 'react';
+                if (deps['vue'])
+                    return 'vue';
+                if (deps['svelte'])
+                    return 'svelte';
+                if (deps['@angular/core'])
+                    return 'angular';
+                if (deps['express'])
+                    return 'express';
+                if (deps['fastify'])
+                    return 'fastify';
+                if (deps['koa'])
+                    return 'koa';
+                if (deps['hono'])
+                    return 'hono';
+                if (deps['electron'])
+                    return 'electron';
+                return null;
+            }
+            catch {
+                return null;
+            }
+        },
+        nameExtractor: (content) => {
+            try {
+                const pkg = JSON.parse(content);
+                return pkg.name ?? null;
+            }
+            catch {
+                return null;
+            }
+        },
+    },
+    // Go
+    {
+        file: 'go.mod',
+        language: 'go',
+        packageManager: 'go',
+        nameExtractor: (content) => {
+            const match = content.match(/^module\s+(.+)$/m);
+            if (match) {
+                // Extract just the last part of the module path
+                const parts = match[1].split('/');
+                return parts[parts.length - 1];
+            }
+            return null;
+        },
+    },
+    // Python
+    {
+        file: 'pyproject.toml',
+        language: 'python',
+        packageManager: 'pip', // Could be poetry, pdm, etc.
+        frameworkDetector: (content) => {
+            if (content.includes('fastapi'))
+                return 'fastapi';
+            if (content.includes('django'))
+                return 'django';
+            if (content.includes('flask'))
+                return 'flask';
+            return null;
+        },
+        nameExtractor: (content) => {
+            const match = content.match(/^name\s*=\s*["'](.+)["']/m);
+            return match ? match[1] : null;
+        },
+    },
+    {
+        file: 'requirements.txt',
+        language: 'python',
+        packageManager: 'pip',
+        frameworkDetector: (content) => {
+            if (content.includes('fastapi'))
+                return 'fastapi';
+            if (content.includes('django'))
+                return 'django';
+            if (content.includes('flask'))
+                return 'flask';
+            return null;
+        },
+    },
+    {
+        file: 'setup.py',
+        language: 'python',
+        packageManager: 'pip',
+    },
+    // Rust
+    {
+        file: 'Cargo.toml',
+        language: 'rust',
+        packageManager: 'cargo',
+        nameExtractor: (content) => {
+            const match = content.match(/^name\s*=\s*["'](.+)["']/m);
+            return match ? match[1] : null;
+        },
+    },
+    // Java
+    {
+        file: 'pom.xml',
+        language: 'java',
+        packageManager: 'maven',
+    },
+    {
+        file: 'build.gradle',
+        language: 'java',
+        packageManager: 'gradle',
+    },
+    {
+        file: 'build.gradle.kts',
+        language: 'kotlin',
+        packageManager: 'gradle',
+    },
+    // PHP
+    {
+        file: 'composer.json',
+        language: 'php',
+        packageManager: 'composer',
+        frameworkDetector: (content) => {
+            try {
+                const pkg = JSON.parse(content);
+                const deps = pkg.require ?? {};
+                if (deps['laravel/framework'])
+                    return 'laravel';
+                if (deps['symfony/framework-bundle'])
+                    return 'symfony';
+                return null;
+            }
+            catch {
+                return null;
+            }
+        },
+        nameExtractor: (content) => {
+            try {
+                const pkg = JSON.parse(content);
+                if (pkg.name) {
+                    // composer names are vendor/package, extract just package
+                    const parts = pkg.name.split('/');
+                    return parts[parts.length - 1];
+                }
+                return null;
+            }
+            catch {
+                return null;
+            }
+        },
+    },
+    // Ruby
+    {
+        file: 'Gemfile',
+        language: 'ruby',
+        packageManager: 'bundler',
+        frameworkDetector: (content) => {
+            if (content.includes("'rails'") || content.includes('"rails"'))
+                return 'rails';
+            if (content.includes("'sinatra'") || content.includes('"sinatra"'))
+                return 'sinatra';
+            return null;
+        },
+    },
+    // .NET
+    {
+        file: '*.csproj',
+        language: 'dotnet',
+        packageManager: 'nuget',
+    },
+    {
+        file: '*.fsproj',
+        language: 'dotnet',
+        packageManager: 'nuget',
+    },
+];
+// =============================================================================
+// Main Detection Functions
+// =============================================================================
+/**
+ * Detect project information from a directory path
+ */
+export function detectProjectInfo(projectPath) {
+    const folderName = path.basename(projectPath);
+    // Initialize with defaults
+    const result = {
+        name: folderName,
+        displayName: prettifyName(folderName),
+        nameSource: 'folder',
+        language: null,
+        framework: null,
+        packageManager: null,
+        hasGit: false,
+        gitRemote: null,
+        gitBranch: null,
+        hasCompilrMd: false,
+        hasClaudeMd: false,
+    };
+    // Check for COMPILR.md and CLAUDE.md
+    result.hasCompilrMd = fs.existsSync(path.join(projectPath, 'COMPILR.md'));
+    result.hasClaudeMd = fs.existsSync(path.join(projectPath, 'CLAUDE.md'));
+    // Detect git info
+    const gitInfo = detectGitInfo(projectPath);
+    result.hasGit = gitInfo.hasGit;
+    result.gitRemote = gitInfo.remote;
+    result.gitBranch = gitInfo.branch;
+    // Detect language and framework from markers
+    for (const marker of LANGUAGE_MARKERS) {
+        // Handle glob patterns (*.csproj)
+        let filePath = null;
+        if (marker.file.includes('*')) {
+            const pattern = marker.file.replace('*', '');
+            try {
+                const files = fs.readdirSync(projectPath);
+                const match = files.find((f) => f.endsWith(pattern));
+                if (match) {
+                    filePath = path.join(projectPath, match);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        else {
+            filePath = path.join(projectPath, marker.file);
+        }
+        if (filePath && fs.existsSync(filePath)) {
+            // First match wins for language
+            if (!result.language) {
+                result.language = marker.language;
+            }
+            // Try to read content for framework detection and name extraction
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                // Extract name if possible
+                if (marker.nameExtractor && result.nameSource === 'folder') {
+                    const extractedName = marker.nameExtractor(content);
+                    if (extractedName) {
+                        result.name = extractedName;
+                        result.displayName = prettifyName(extractedName);
+                        result.nameSource = marker.file;
+                    }
+                }
+                // Detect framework
+                if (!result.framework && marker.frameworkDetector) {
+                    result.framework = marker.frameworkDetector(content);
+                }
+                // Set package manager
+                if (!result.packageManager && marker.packageManager) {
+                    result.packageManager = marker.packageManager;
+                }
+            }
+            catch {
+                // File read failed, continue
+            }
+        }
+    }
+    // Detect package manager overrides for Node.js
+    if (result.language === 'node') {
+        if (fs.existsSync(path.join(projectPath, 'pnpm-lock.yaml'))) {
+            result.packageManager = 'pnpm';
+        }
+        else if (fs.existsSync(path.join(projectPath, 'yarn.lock'))) {
+            result.packageManager = 'yarn';
+        }
+        else if (fs.existsSync(path.join(projectPath, 'bun.lockb'))) {
+            result.packageManager = 'bun';
+        }
+    }
+    // Detect package manager overrides for Python
+    if (result.language === 'python') {
+        if (fs.existsSync(path.join(projectPath, 'poetry.lock'))) {
+            result.packageManager = 'poetry';
+        }
+        else if (fs.existsSync(path.join(projectPath, 'pdm.lock'))) {
+            result.packageManager = 'pdm';
+        }
+        else if (fs.existsSync(path.join(projectPath, 'uv.lock'))) {
+            result.packageManager = 'uv';
+        }
+    }
+    return result;
+}
+/**
+ * Detect git repository information
+ */
+export function detectGitInfo(projectPath) {
+    const result = {
+        hasGit: false,
+        remote: null,
+        branch: null,
+    };
+    const gitPath = path.join(projectPath, '.git');
+    if (!fs.existsSync(gitPath)) {
+        return result;
+    }
+    result.hasGit = true;
+    // Try to get remote URL using git command
+    try {
+        const remote = execSync('git remote get-url origin', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (remote) {
+            result.remote = remote;
+        }
+    }
+    catch {
+        // No remote configured or git command failed
+    }
+    // Try to get current branch
+    try {
+        const branch = execSync('git branch --show-current', {
+            cwd: projectPath,
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (branch) {
+            result.branch = branch;
+        }
+    }
+    catch {
+        // Not on a branch (detached HEAD) or git command failed
+    }
+    return result;
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
+/**
+ * Convert kebab-case or snake_case to Title Case
+ */
+function prettifyName(name) {
+    return name
+        .replace(/[-_]/g, ' ')
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+/**
+ * Get a human-readable label for detected language
+ */
+export function getLanguageLabel(language) {
+    if (!language)
+        return 'Unknown';
+    const labels = {
+        node: 'Node.js / TypeScript',
+        go: 'Go',
+        python: 'Python',
+        rust: 'Rust',
+        java: 'Java',
+        kotlin: 'Kotlin',
+        php: 'PHP',
+        ruby: 'Ruby',
+        dotnet: '.NET (C#/F#)',
+    };
+    return labels[language] ?? language;
+}
+/**
+ * Get a human-readable label for detected framework
+ */
+export function getFrameworkLabel(framework) {
+    if (!framework)
+        return 'Not detected';
+    const labels = {
+        react: 'React',
+        vue: 'Vue.js',
+        svelte: 'Svelte',
+        angular: 'Angular',
+        next: 'Next.js',
+        nuxt: 'Nuxt.js',
+        express: 'Express.js',
+        fastify: 'Fastify',
+        koa: 'Koa',
+        hono: 'Hono',
+        electron: 'Electron',
+        fastapi: 'FastAPI',
+        django: 'Django',
+        flask: 'Flask',
+        rails: 'Ruby on Rails',
+        sinatra: 'Sinatra',
+        laravel: 'Laravel',
+        symfony: 'Symfony',
+    };
+    return labels[framework] ?? framework;
+}
+/**
+ * Check if a path is a valid directory that can be imported
+ */
+export function validateImportPath(importPath) {
+    // Check if path exists
+    if (!fs.existsSync(importPath)) {
+        return { valid: false, error: 'Path does not exist' };
+    }
+    // Check if it's a directory
+    try {
+        const stats = fs.statSync(importPath);
+        if (!stats.isDirectory()) {
+            return { valid: false, error: 'Path is not a directory' };
+        }
+    }
+    catch {
+        return { valid: false, error: 'Cannot access path' };
+    }
+    return { valid: true };
+}

package/dist/utils/project-memory.js

@@ -6,6 +6,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
+import { estimateTokens } from './token-tracker.js';
 // =============================================================================
 // Constants
 // =============================================================================
@@ -59,7 +60,7 @@ export function loadProjectMemory(options = {}) {
                     filePath,
                     originalSize,
                     truncated,
-                    estimatedTokens: Math.ceil(content.length / 4),
+                    estimatedTokens: estimateTokens(content),
                 };
             }
             catch {

package/dist/utils/project-status.d.ts

@@ -2,8 +2,8 @@
  * Project Status Detection
  * Detects project state for startup message guidance
  */
-import type { CompilrConfig } from '../templates/config-json.js';
-export type { CompilrConfig } from '../templates/config-json.js';
+import type { CompilrConfig } from './types/config-types.js';
+export type { CompilrConfig } from './types/config-types.js';
 export interface ProjectStatus {
     /** .compilr/ folder exists */
     initialized: boolean;

package/dist/utils/startup-perf.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Startup Performance Profiler
+ *
+ * Lightweight timing utility for diagnosing CLI startup latency.
+ * Always collects timestamps (Date.now() is ~nanosecond cost).
+ * Writes results to ~/.compilr-dev/startup-perf.log on flush.
+ *
+ * Foundation layer — no imports from domain or app layers.
+ */
+/**
+ * Record a timing mark. Cheap — just pushes to an array.
+ */
+export declare function perf(label: string): void;
+/**
+ * Flush the startup profile to ~/.compilr-dev/startup-perf.log.
+ * Overwrites previous log (only the latest startup matters).
+ */
+export declare function flushStartupPerf(): void;

package/dist/utils/startup-perf.js

@@ -0,0 +1,60 @@
+/**
+ * Startup Performance Profiler
+ *
+ * Lightweight timing utility for diagnosing CLI startup latency.
+ * Always collects timestamps (Date.now() is ~nanosecond cost).
+ * Writes results to ~/.compilr-dev/startup-perf.log on flush.
+ *
+ * Foundation layer — no imports from domain or app layers.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getDataPath } from '../settings/paths.js';
+const marks = [];
+const t0 = Date.now();
+/**
+ * Record a timing mark. Cheap — just pushes to an array.
+ */
+export function perf(label) {
+    marks.push({ label, time: Date.now() });
+}
+/**
+ * Flush the startup profile to ~/.compilr-dev/startup-perf.log.
+ * Overwrites previous log (only the latest startup matters).
+ */
+export function flushStartupPerf() {
+    if (marks.length === 0)
+        return;
+    const lines = [];
+    const totalMs = marks[marks.length - 1].time - t0;
+    lines.push(`=== Startup Profile: ${new Date().toISOString()} ===`);
+    lines.push(`Total: ${String(totalMs)}ms (${String(marks.length)} marks)\n`);
+    let prev = t0;
+    for (const mark of marks) {
+        const elapsed = mark.time - t0;
+        const delta = mark.time - prev;
+        const bar = delta > 50 ? ` ${'█'.repeat(Math.min(40, Math.round(delta / 50)))}` : '';
+        lines.push(`  ${String(elapsed).padStart(6)}ms  +${String(delta).padStart(5)}ms  ${mark.label}${bar}`);
+        prev = mark.time;
+    }
+    lines.push('');
+    // Highlight slow steps (>100ms)
+    const slow = marks
+        .map((m, i) => ({ label: m.label, delta: m.time - (i > 0 ? marks[i - 1].time : t0) }))
+        .filter(m => m.delta > 100)
+        .sort((a, b) => b.delta - a.delta);
+    if (slow.length > 0) {
+        lines.push('Slow steps (>100ms):');
+        for (const s of slow) {
+            lines.push(`  ${String(s.delta).padStart(5)}ms  ${s.label}`);
+        }
+        lines.push('');
+    }
+    try {
+        const logPath = path.join(getDataPath(), 'startup-perf.log');
+        fs.writeFileSync(logPath, lines.join('\n'), 'utf-8');
+    }
+    catch {
+        // Best effort — don't crash on log write failure
+    }
+}

package/dist/utils/token-tracker.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Token Tracker
+ *
+ * Tracks token usage breakdown for debugging and optimization.
+ * Estimates are calculated when the agent is created and updated
+ * as context changes (messages added, etc.).
+ */
+import type { TokenBreakdown } from './token-types.js';
+export interface TokenEstimates {
+    system: number;
+    role: number;
+    tools: number;
+    context: number;
+    history: number;
+}
+/**
+ * Count tokens using tiktoken (cl100k_base encoding)
+ */
+export declare function estimateTokens(text: string | undefined): number;
+/**
+ * Count tokens for a JSON object (tool definition, etc.)
+ */
+export declare function estimateJsonTokens(obj: unknown): number;
+/**
+ * Set static token estimates (called at agent creation)
+ */
+export declare function setStaticEstimates(estimates: {
+    system: number;
+    role: number;
+    tools: number;
+    context: number;
+}): void;
+/**
+ * Update history token estimate (called before each request)
+ */
+export declare function updateHistoryEstimate(historyTokens: number): void;
+/**
+ * Update cache info from API response
+ */
+export declare function updateCacheInfo(cacheRead: number, cacheCreation: number): void;
+/**
+ * Get current breakdown for display
+ */
+export declare function getTokenBreakdown(): TokenBreakdown;
+/**
+ * Get total estimated tokens
+ */
+export declare function getTotalEstimate(): number;
+/**
+ * Reset all estimates (for new agent/session)
+ */
+export declare function resetEstimates(): void;
+/**
+ * Format breakdown for display (compact form)
+ * Example: "sys:2k role:1k tools:12k ctx:0.4k hist:3k"
+ */
+export declare function formatBreakdownCompact(): string;
+/**
+ * Format cache info for display
+ * Example: "cached:18k new:5k"
+ */
+export declare function formatCacheInfo(): string | null;