@compilr-dev/cli 0.4.0

package/dist/utils/project-memory.js

@@ -0,0 +1,117 @@
+/**
+ * Project Memory Loader
+ *
+ * Loads project-level instructions from COMPILR.md or CLAUDE.md files.
+ * Provides size guards and warnings for large files.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+// =============================================================================
+// Constants
+// =============================================================================
+/** Files to search for, in priority order */
+const MEMORY_FILES = [
+    'COMPILR.md',
+    '.compilr/instructions.md',
+    'CLAUDE.md',
+    '.claude/instructions.md',
+];
+/** Default max size: 100KB */
+const DEFAULT_MAX_SIZE = 100 * 1024;
+/** Default warn size: 30KB */
+const DEFAULT_WARN_SIZE = 30 * 1024;
+// =============================================================================
+// Main Function
+// =============================================================================
+/**
+ * Load project memory from COMPILR.md or CLAUDE.md
+ *
+ * @param options - Configuration options
+ * @returns Result with content and metadata
+ */
+export function loadProjectMemory(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const maxSize = options.maxSize ?? DEFAULT_MAX_SIZE;
+    // Search for memory file
+    for (const filename of MEMORY_FILES) {
+        const filePath = path.join(cwd, filename);
+        if (fs.existsSync(filePath)) {
+            try {
+                const stat = fs.statSync(filePath);
+                const originalSize = stat.size;
+                // Read file content
+                let content = fs.readFileSync(filePath, 'utf-8');
+                let truncated = false;
+                // Truncate if too large
+                if (content.length > maxSize) {
+                    content = content.slice(0, maxSize);
+                    // Try to truncate at a line boundary
+                    const lastNewline = content.lastIndexOf('\n');
+                    if (lastNewline > maxSize * 0.8) {
+                        content = content.slice(0, lastNewline);
+                    }
+                    content += '\n\n[... truncated due to size ...]';
+                    truncated = true;
+                }
+                return {
+                    found: true,
+                    content,
+                    filePath,
+                    originalSize,
+                    truncated,
+                    estimatedTokens: Math.ceil(content.length / 4),
+                };
+            }
+            catch {
+                // File exists but couldn't be read, continue to next
+                continue;
+            }
+        }
+    }
+    // No memory file found
+    return {
+        found: false,
+        content: '',
+        filePath: null,
+        originalSize: 0,
+        truncated: false,
+        estimatedTokens: 0,
+    };
+}
+/**
+ * Check if a project memory file exists without loading it
+ */
+export function hasProjectMemory(cwd) {
+    const dir = cwd ?? process.cwd();
+    for (const filename of MEMORY_FILES) {
+        const filePath = path.join(dir, filename);
+        if (fs.existsSync(filePath)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Get the size category for display purposes
+ */
+export function getSizeCategory(bytes) {
+    if (bytes < DEFAULT_WARN_SIZE) {
+        return 'small';
+    }
+    else if (bytes < DEFAULT_MAX_SIZE) {
+        return 'medium';
+    }
+    return 'large';
+}
+/**
+ * Format bytes as human-readable string
+ */
+export function formatBytes(bytes) {
+    if (bytes < 1024) {
+        return `${String(bytes)} B`;
+    }
+    else if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    }
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

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

@@ -0,0 +1,56 @@
+/**
+ * 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';
+export interface ProjectStatus {
+    /** .compilr/ folder exists */
+    initialized: boolean;
+    /** COMPILR.md or CLAUDE.md exists */
+    hasMemory: boolean;
+    /** backlog.md exists in .compilr/ or root */
+    hasBacklog: boolean;
+    /** Backlog statistics (if backlog exists) */
+    backlogStats: {
+        total: number;
+        completed: number;
+        inProgress: number;
+        pending: number;
+    } | null;
+    /** PRD.md exists */
+    hasPRD: boolean;
+    /** architecture/ folder exists */
+    hasArchDocs: boolean;
+    /** Existing project markers (package.json, .git, Cargo.toml, etc.) */
+    isExistingProject: boolean;
+    /** Project type if detected */
+    projectType: string | null;
+}
+/**
+ * Detect project status for the current working directory
+ */
+export declare function detectProjectStatus(cwd?: string): ProjectStatus;
+/**
+ * Find and load the .compilr/config.json file
+ * Searches in cwd, parent dirs, and sibling -docs folders
+ */
+export declare function loadCompilrConfig(cwd?: string): CompilrConfig | null;
+/**
+ * Find the path to .compilr/config.json
+ * Returns null if not found
+ */
+export declare function findConfigPath(cwd?: string): string | null;
+/**
+ * Get the project path from config, falling back to cwd
+ */
+export declare function getProjectPath(cwd?: string): string;
+/**
+ * Get the docs path from config (for two-repo pattern)
+ */
+export declare function getDocsPath(cwd?: string): string | null;
+/**
+ * Get workflow stage based on project status
+ */
+export type WorkflowStage = 'new' | 'initialized' | 'designing' | 'building' | 'maintaining';
+export declare function getWorkflowStage(status: ProjectStatus): WorkflowStage;

package/dist/utils/project-status.js

@@ -0,0 +1,237 @@
+/**
+ * Project Status Detection
+ * Detects project state for startup message guidance
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Detect project status for the current working directory
+ */
+export function detectProjectStatus(cwd = process.cwd()) {
+    const status = {
+        initialized: false,
+        hasMemory: false,
+        hasBacklog: false,
+        backlogStats: null,
+        hasPRD: false,
+        hasArchDocs: false,
+        isExistingProject: false,
+        projectType: null,
+    };
+    // Check .compilr/ folder (future) or .claude/ (current)
+    status.initialized = existsSync(join(cwd, '.compilr')) || existsSync(join(cwd, '.claude'));
+    // Check for memory file (COMPILR.md, CLAUDE.md, or similar)
+    const memoryFiles = ['COMPILR.md', 'CLAUDE.md', 'GEMINI.md', 'COPILOT.md'];
+    status.hasMemory = memoryFiles.some(f => existsSync(join(cwd, f)));
+    // Check for backlog
+    const backlogPaths = [
+        join(cwd, '.compilr', 'backlog.md'),
+        join(cwd, '.claude', 'backlog.md'),
+        join(cwd, 'backlog.md'),
+    ];
+    const backlogPath = backlogPaths.find(p => existsSync(p));
+    status.hasBacklog = !!backlogPath;
+    // Parse backlog stats if it exists
+    if (backlogPath) {
+        status.backlogStats = parseBacklogStats(backlogPath);
+    }
+    // Check for PRD
+    const prdPaths = [
+        join(cwd, '.compilr', 'PRD.md'),
+        join(cwd, '.claude', 'PRD.md'),
+        join(cwd, 'docs', 'PRD.md'),
+        join(cwd, 'PRD.md'),
+    ];
+    status.hasPRD = prdPaths.some(p => existsSync(p));
+    // Check for architecture docs
+    const archPaths = [
+        join(cwd, '.compilr', 'architecture'),
+        join(cwd, '.claude', 'architecture'),
+        join(cwd, 'docs', 'architecture'),
+        join(cwd, 'architecture'),
+    ];
+    status.hasArchDocs = archPaths.some(p => {
+        try {
+            return existsSync(p) && statSync(p).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    // Check for existing project markers
+    const projectMarkers = [
+        ['package.json', 'node'],
+        ['Cargo.toml', 'rust'],
+        ['go.mod', 'go'],
+        ['pyproject.toml', 'python'],
+        ['requirements.txt', 'python'],
+        ['Gemfile', 'ruby'],
+        ['pom.xml', 'java'],
+        ['build.gradle', 'java'],
+        ['composer.json', 'php'],
+    ];
+    for (const [marker, type] of projectMarkers) {
+        if (existsSync(join(cwd, marker))) {
+            status.isExistingProject = true;
+            status.projectType = type;
+            break;
+        }
+    }
+    // Also check for .git as a project marker
+    if (!status.isExistingProject && existsSync(join(cwd, '.git'))) {
+        status.isExistingProject = true;
+    }
+    return status;
+}
+/**
+ * Parse backlog.md to count items by status
+ */
+function parseBacklogStats(backlogPath) {
+    try {
+        const content = readFileSync(backlogPath, 'utf-8');
+        const lines = content.split('\n');
+        let total = 0;
+        let completed = 0;
+        let inProgress = 0;
+        let pending = 0;
+        // Look for status indicators in table rows or list items
+        // Patterns: ✅, 🚧, 📋, [x], [ ], - [ ], etc.
+        for (const line of lines) {
+            // Skip header rows and empty lines
+            if (line.startsWith('#') || line.startsWith('|--') || !line.trim())
+                continue;
+            // Check for status indicators
+            if (line.includes('✅') || line.includes('[x]') || line.includes('[X]')) {
+                total++;
+                completed++;
+            }
+            else if (line.includes('🚧') || line.includes('In Progress') || line.includes('in_progress')) {
+                total++;
+                inProgress++;
+            }
+            else if (line.includes('📋') || line.includes('Planned') || line.includes('[ ]') || line.includes('pending')) {
+                total++;
+                pending++;
+            }
+        }
+        return { total, completed, inProgress, pending };
+    }
+    catch {
+        return null;
+    }
+}
+// =============================================================================
+// Compilr Config Loading
+// =============================================================================
+/**
+ * Find and load the .compilr/config.json file
+ * Searches in cwd, parent dirs, and sibling -docs folders
+ */
+export function loadCompilrConfig(cwd = process.cwd()) {
+    const configPath = findConfigPath(cwd);
+    if (!configPath)
+        return null;
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find the path to .compilr/config.json
+ * Returns null if not found
+ */
+export function findConfigPath(cwd = process.cwd()) {
+    // Check in current directory
+    const localConfig = join(cwd, '.compilr', 'config.json');
+    if (existsSync(localConfig))
+        return localConfig;
+    // Check for .claude/ (legacy)
+    const legacyConfig = join(cwd, '.claude', 'config.json');
+    if (existsSync(legacyConfig))
+        return legacyConfig;
+    // Check for sibling -docs folder (two-repo pattern)
+    const parentDir = join(cwd, '..');
+    const currentDirName = cwd.split('/').pop() ?? '';
+    // If we're in project-name, check project-name-docs
+    const docsFolder = join(parentDir, `${currentDirName}-docs`, '.compilr', 'config.json');
+    if (existsSync(docsFolder))
+        return docsFolder;
+    // If we're in project-name-docs, the config is already here
+    // (handled by localConfig check above)
+    // Check subfolders (if cwd is parent of project)
+    try {
+        const entries = readdirSync(cwd, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                // Check for .compilr in subfolder
+                const subConfig = join(cwd, entry.name, '.compilr', 'config.json');
+                if (existsSync(subConfig))
+                    return subConfig;
+                // Check for -docs sibling pattern
+                if (entry.name.endsWith('-docs')) {
+                    const subDocsConfig = join(cwd, entry.name, '.compilr', 'config.json');
+                    if (existsSync(subDocsConfig))
+                        return subDocsConfig;
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Get the project path from config, falling back to cwd
+ */
+export function getProjectPath(cwd = process.cwd()) {
+    const config = loadCompilrConfig(cwd);
+    if (config && config.paths.project) {
+        return config.paths.project;
+    }
+    return cwd;
+}
+/**
+ * Get the docs path from config (for two-repo pattern)
+ */
+export function getDocsPath(cwd = process.cwd()) {
+    const config = loadCompilrConfig(cwd);
+    if (config) {
+        return config.paths.docs;
+    }
+    return null;
+}
+export function getWorkflowStage(status) {
+    // New project - nothing exists
+    if (!status.initialized && !status.isExistingProject) {
+        return 'new';
+    }
+    // Existing project but not initialized with compilr
+    if (!status.initialized && status.isExistingProject) {
+        return 'initialized';
+    }
+    // Has backlog with items - building or maintaining
+    if (status.hasBacklog && status.backlogStats) {
+        const { total, completed, pending, inProgress } = status.backlogStats;
+        // If most items are completed, we're in maintenance mode
+        if (total > 0 && completed / total > 0.8) {
+            return 'maintaining';
+        }
+        // If there are pending or in-progress items, we're building
+        if (inProgress > 0 || pending > 0) {
+            return 'building';
+        }
+    }
+    // Has PRD but no backlog - still designing
+    if (status.hasPRD && !status.hasBacklog) {
+        return 'designing';
+    }
+    // Initialized but no requirements - need to design
+    if (status.initialized && !status.hasPRD && !status.hasBacklog) {
+        return 'designing';
+    }
+    return 'initialized';
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@compilr-dev/cli",
+  "version": "0.4.0",
+  "description": "AI-powered coding assistant CLI using @compilr-dev/agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "compilr": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsc && node dist/index.js",
+    "clean": "rm -rf dist",
+    "lint": "eslint src/",
+    "lint:fix": "eslint src/ --fix",
+    "prepublishOnly": "npm run lint && npm run build"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "coding-assistant",
+    "agents",
+    "llm",
+    "claude",
+    "openai",
+    "terminal"
+  ],
+  "author": "Carmelo Scozzola",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/compilr-dev/cli.git"
+  },
+  "homepage": "https://compilr.dev",
+  "bugs": {
+    "url": "https://github.com/compilr-dev/cli/issues"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.30.1",
+    "@compilr-dev/agents": "^0.2.1",
+    "@compilr-dev/agents-coding": "^0.1.1",
+    "better-sqlite3": "^12.5.0",
+    "chalk": "^5.6.2",
+    "marked": "^15.0.12",
+    "marked-terminal": "^7.3.0",
+    "picocolors": "^1.1.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/marked-terminal": "^6.1.1",
+    "@types/node": "^22.0.0",
+    "eslint": "^9.39.1",
+    "typescript": "^5.3.0",
+    "typescript-eslint": "^8.48.0"
+  }
+}