@tonycasey/lisa 0.5.13

package/dist/templates/claude/hooks/common/complexity-rater.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Scoring constants
+const POINTS = {
+    FILE_CREATED: 3,
+    FILE_EDITED: 2,
+    COMMAND_RUN: 1.5,
+    DOC_CREATED: 2,
+    TEST_MODIFIED: 1.5,
+    CONFIG_FILE: 1,
+    VERSION_BUMP: 2,
+    STRUCTURAL_CHANGE: 2,
+    MULTI_DIRECTORY: 3,
+    CI_CD_SETUP: 3,
+};
+const MULTIPLIERS = {
+    TOOL_DIVERSITY_5: 1.2,
+    TOOL_DIVERSITY_8: 1.3,
+};
+// Score thresholds for rating normalization
+const THRESHOLDS = {
+    RATING_2: 2,
+    RATING_3: 5,
+    RATING_4: 10,
+    RATING_5: 20,
+};
+// Version files to detect version bumps
+const VERSION_FILES = ['package.json', 'pyproject.toml', 'Cargo.toml', 'setup.py', 'version.py', 'VERSION'];
+// Config files that indicate setup/configuration work
+const CONFIG_PATTERNS = [
+    'tsconfig.json',
+    'tsconfig',
+    'jest.config',
+    '.eslintrc',
+    '.prettierrc',
+    'webpack.config',
+    'vite.config',
+    'rollup.config',
+    '.gitignore',
+    '.dockerignore',
+    'Dockerfile',
+    'docker-compose',
+    '.github/workflows',
+    '.gitlab-ci',
+    'Makefile',
+    'CMakeLists',
+];
+// CI/CD indicators
+const CI_CD_PATTERNS = ['.github/workflows', '.gitlab-ci', 'Jenkinsfile', '.circleci', '.travis'];
+/**
+ * Rate the complexity of work based on signals
+ */
+function rateComplexity(work) {
+    const signals = extractSignals(work);
+    const rawScore = calculateRawScore(signals, work);
+    const rating = normalizeToRating(rawScore);
+    const signalDescriptions = describeSignals(signals, work);
+    const summary = generateSummary(rating, signals, work);
+    return {
+        rating,
+        rawScore: Math.round(rawScore * 10) / 10,
+        signals: signalDescriptions,
+        summary,
+    };
+}
+/**
+ * Extract complexity signals from work summary
+ */
+function extractSignals(work) {
+    const filesModified = work.filesModified.size;
+    const filesCreated = work.filesCreated.size;
+    const allFiles = [...work.filesModified, ...work.filesCreated];
+    return {
+        filesModified,
+        filesCreated,
+        versionBump: hasVersionBump(allFiles),
+        docsCreated: countDocs(work.filesCreated),
+        testsModified: countTests(allFiles),
+        configFiles: countConfigFiles(allFiles),
+        structuralChanges: countStructuralChanges(work.commandsRun),
+        toolDiversity: work.toolsUsed.size,
+        commandCount: work.commandsRun.length,
+    };
+}
+/**
+ * Calculate raw score from signals
+ */
+function calculateRawScore(signals, work) {
+    let score = 0;
+    // Base points for file operations
+    score += signals.filesCreated * POINTS.FILE_CREATED;
+    score += signals.filesModified * POINTS.FILE_EDITED;
+    // Points for commands (weighted)
+    score += signals.commandCount * POINTS.COMMAND_RUN;
+    // Bonus points for specific types
+    score += signals.docsCreated * POINTS.DOC_CREATED;
+    score += signals.testsModified * POINTS.TEST_MODIFIED;
+    score += signals.configFiles * POINTS.CONFIG_FILE;
+    // Bonus for version bump
+    if (signals.versionBump) {
+        score += POINTS.VERSION_BUMP;
+    }
+    // Bonus for structural changes
+    score += signals.structuralChanges * POINTS.STRUCTURAL_CHANGE;
+    // Bonus for multi-directory work
+    if (hasMultiDirectoryWork(work)) {
+        score += POINTS.MULTI_DIRECTORY;
+    }
+    // Bonus for CI/CD setup
+    if (hasCICDSetup(work)) {
+        score += POINTS.CI_CD_SETUP;
+    }
+    // Apply multipliers for tool diversity
+    if (signals.toolDiversity >= 8) {
+        score *= MULTIPLIERS.TOOL_DIVERSITY_8;
+    }
+    else if (signals.toolDiversity >= 5) {
+        score *= MULTIPLIERS.TOOL_DIVERSITY_5;
+    }
+    return score;
+}
+/**
+ * Normalize raw score to 1-5 rating
+ */
+function normalizeToRating(rawScore) {
+    if (rawScore >= THRESHOLDS.RATING_5)
+        return 5;
+    if (rawScore >= THRESHOLDS.RATING_4)
+        return 4;
+    if (rawScore >= THRESHOLDS.RATING_3)
+        return 3;
+    if (rawScore >= THRESHOLDS.RATING_2)
+        return 2;
+    return 1;
+}
+/**
+ * Check if any version files were modified
+ */
+function hasVersionBump(files) {
+    return files.some((filePath) => VERSION_FILES.some((vf) => filePath.endsWith(vf) || filePath.includes(vf)));
+}
+/**
+ * Count documentation files created
+ */
+function countDocs(filesCreated) {
+    return Array.from(filesCreated).filter((filePath) => filePath.endsWith('.md') || filePath.includes('/docs/') || filePath.toUpperCase().includes('README')).length;
+}
+/**
+ * Count test files modified or created
+ */
+function countTests(files) {
+    return files.filter((filePath) => /\.(test|spec)\.(ts|js|tsx|jsx|py|rs)$/.test(filePath) ||
+        filePath.includes('/tests/') ||
+        filePath.includes('/__tests__/') ||
+        filePath.includes('/test/')).length;
+}
+/**
+ * Count config files modified
+ */
+function countConfigFiles(files) {
+    return files.filter((filePath) => CONFIG_PATTERNS.some((pattern) => filePath.includes(pattern))).length;
+}
+/**
+ * Count structural changes (mkdir commands)
+ */
+function countStructuralChanges(commands) {
+    return commands.filter((cmd) => cmd.startsWith('mkdir') || cmd.includes('mkdir ')).length;
+}
+/**
+ * Check if work spans multiple directories
+ */
+function hasMultiDirectoryWork(work) {
+    const allFiles = [...work.filesModified, ...work.filesCreated];
+    const directories = new Set();
+    for (const filePath of allFiles) {
+        const parts = filePath.split('/');
+        if (parts.length > 1) {
+            directories.add(parts[0]);
+        }
+    }
+    return directories.size >= 3;
+}
+/**
+ * Check if CI/CD files were created/modified
+ */
+function hasCICDSetup(work) {
+    const allFiles = [...work.filesModified, ...work.filesCreated];
+    return allFiles.some((filePath) => CI_CD_PATTERNS.some((pattern) => filePath.includes(pattern)));
+}
+/**
+ * Generate human-readable signal descriptions
+ */
+function describeSignals(signals, work) {
+    const descriptions = [];
+    if (signals.filesCreated > 0) {
+        descriptions.push(`${signals.filesCreated} file${signals.filesCreated > 1 ? 's' : ''} created`);
+    }
+    if (signals.filesModified > 0) {
+        descriptions.push(`${signals.filesModified} file${signals.filesModified > 1 ? 's' : ''} modified`);
+    }
+    if (signals.testsModified > 0) {
+        descriptions.push(`${signals.testsModified} test file${signals.testsModified > 1 ? 's' : ''}`);
+    }
+    if (signals.docsCreated > 0) {
+        descriptions.push(`${signals.docsCreated} documentation file${signals.docsCreated > 1 ? 's' : ''}`);
+    }
+    if (signals.versionBump) {
+        descriptions.push('Version bump detected');
+    }
+    if (signals.configFiles > 0) {
+        descriptions.push(`${signals.configFiles} config file${signals.configFiles > 1 ? 's' : ''}`);
+    }
+    if (signals.structuralChanges > 0) {
+        descriptions.push(`${signals.structuralChanges} structural change${signals.structuralChanges > 1 ? 's' : ''}`);
+    }
+    if (hasMultiDirectoryWork(work)) {
+        descriptions.push('Multi-directory changes');
+    }
+    if (hasCICDSetup(work)) {
+        descriptions.push('CI/CD setup');
+    }
+    if (signals.toolDiversity >= 5) {
+        descriptions.push(`${signals.toolDiversity} different tools used`);
+    }
+    return descriptions;
+}
+/**
+ * Generate a summary description of the work
+ */
+function generateSummary(rating, signals, work) {
+    const ratingLabels = {
+        1: 'Trivial',
+        2: 'Simple',
+        3: 'Moderate',
+        4: 'Complex',
+        5: 'Very Complex',
+    };
+    const label = ratingLabels[rating] || 'Unknown';
+    const totalFiles = signals.filesCreated + signals.filesModified;
+    // Generate contextual summary
+    if (rating === 1) {
+        if (totalFiles === 0) {
+            return `${label}: Read-only session or minimal interaction`;
+        }
+        return `${label}: Minor change to ${totalFiles} file${totalFiles > 1 ? 's' : ''}`;
+    }
+    if (rating === 2) {
+        return `${label}: ${totalFiles} file${totalFiles > 1 ? 's' : ''} affected`;
+    }
+    if (rating === 3) {
+        const extras = [];
+        if (signals.testsModified > 0)
+            extras.push('tests');
+        if (signals.docsCreated > 0)
+            extras.push('docs');
+        const extra = extras.length > 0 ? ` with ${extras.join(' and ')}` : '';
+        return `${label}: Feature implementation${extra}`;
+    }
+    if (rating === 4) {
+        return `${label}: Multi-file refactor or significant feature`;
+    }
+    // Rating 5
+    const highlights = [];
+    if (signals.versionBump)
+        highlights.push('version bump');
+    if (hasCICDSetup(work))
+        highlights.push('CI/CD');
+    if (signals.docsCreated >= 2)
+        highlights.push('documentation');
+    const highlight = highlights.length > 0 ? `: ${highlights.join(', ')}` : '';
+    return `${label}: Major milestone${highlight}`;
+}
+/**
+ * Get rating label
+ */
+function getRatingLabel(rating) {
+    const labels = {
+        1: 'Trivial',
+        2: 'Simple',
+        3: 'Moderate',
+        4: 'Complex',
+        5: 'Very Complex',
+    };
+    return labels[rating] || 'Unknown';
+}
+module.exports = {
+    rateComplexity,
+    getRatingLabel,
+    THRESHOLDS,
+};

package/dist/templates/claude/hooks/common/context.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require('path');
+const fs = require('fs');
+const { execSync } = require('child_process');
+const ENV_FILE = '.agents/.env';
+/**
+ * Parse a .env file into key-value pairs
+ */
+function parseEnvFile(content) {
+    const env = {};
+    content.split(/\r?\n/).forEach((line) => {
+        if (!line || line.startsWith('#'))
+            return;
+        const idx = line.indexOf('=');
+        if (idx === -1)
+            return;
+        env[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+    });
+    return env;
+}
+/**
+ * Read the .agents/.env file
+ */
+function readEnvConfig() {
+    const envPath = path.join(process.cwd(), ENV_FILE);
+    try {
+        if (fs.existsSync(envPath)) {
+            const content = fs.readFileSync(envPath, 'utf8');
+            return parseEnvFile(content);
+        }
+    }
+    catch (_err) {
+        // File doesn't exist or is invalid
+    }
+    return {};
+}
+/**
+ * Write or update PROJECT_NAME in .agents/.env
+ * Preserves existing entries
+ */
+function writeProjectName(projectName, detectedFrom) {
+    const envPath = path.join(process.cwd(), ENV_FILE);
+    const agentsDir = path.join(process.cwd(), '.agents');
+    try {
+        // Ensure .agents directory exists
+        if (!fs.existsSync(agentsDir)) {
+            fs.mkdirSync(agentsDir, { recursive: true });
+        }
+        // Read existing content
+        let lines = [];
+        if (fs.existsSync(envPath)) {
+            lines = fs.readFileSync(envPath, 'utf8').split(/\r?\n/);
+        }
+        // Check if PROJECT_NAME already exists
+        const hasProjectName = lines.some(line => line.trim().startsWith('PROJECT_NAME='));
+        if (!hasProjectName) {
+            // Add PROJECT_NAME with a comment about detection source
+            const newLines = [
+                `# Project name detected from ${detectedFrom}`,
+                `PROJECT_NAME=${projectName}`,
+                '',
+            ];
+            // Prepend to existing content
+            const content = [...newLines, ...lines].join('\n');
+            fs.writeFileSync(envPath, content);
+            return true;
+        }
+    }
+    catch (_err) {
+        // Failed to write - continue without persisting
+    }
+    return false;
+}
+/**
+ * Detect project name from package.json
+ */
+function detectFromPackageJson() {
+    try {
+        const pkgPath = path.join(process.cwd(), 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            if (pkg.name && typeof pkg.name === 'string') {
+                // Strip org scope if present (e.g., @org/package -> package)
+                return pkg.name.replace(/^@[^/]+\//, '');
+            }
+        }
+    }
+    catch (_err) {
+        // Ignore parse errors
+    }
+    return null;
+}
+/**
+ * Detect project name from pyproject.toml (Python)
+ */
+function detectFromPyproject() {
+    try {
+        const pyPath = path.join(process.cwd(), 'pyproject.toml');
+        if (fs.existsSync(pyPath)) {
+            const content = fs.readFileSync(pyPath, 'utf8');
+            // Simple regex to find name in [project] or [tool.poetry] section
+            const match = content.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+            if (match) {
+                return match[1];
+            }
+        }
+    }
+    catch (_err) {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Detect project name from Cargo.toml (Rust)
+ */
+function detectFromCargoToml() {
+    try {
+        const cargoPath = path.join(process.cwd(), 'Cargo.toml');
+        if (fs.existsSync(cargoPath)) {
+            const content = fs.readFileSync(cargoPath, 'utf8');
+            const match = content.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+            if (match) {
+                return match[1];
+            }
+        }
+    }
+    catch (_err) {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Detect project name from go.mod (Go)
+ */
+function detectFromGoMod() {
+    try {
+        const goModPath = path.join(process.cwd(), 'go.mod');
+        if (fs.existsSync(goModPath)) {
+            const content = fs.readFileSync(goModPath, 'utf8');
+            // Module line like: module github.com/user/project
+            const match = content.match(/^\s*module\s+(\S+)/m);
+            if (match) {
+                // Return just the last part (project name)
+                const parts = match[1].split('/');
+                return parts[parts.length - 1];
+            }
+        }
+    }
+    catch (_err) {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Detect project name using the fallback chain
+ * Returns { name, source } where source indicates where it was detected from
+ */
+function detectProjectName() {
+    // 1. Try package.json
+    const pkgName = detectFromPackageJson();
+    if (pkgName) {
+        return { name: pkgName, source: 'package.json' };
+    }
+    // 2. Try pyproject.toml
+    const pyName = detectFromPyproject();
+    if (pyName) {
+        return { name: pyName, source: 'pyproject.toml' };
+    }
+    // 3. Try Cargo.toml
+    const cargoName = detectFromCargoToml();
+    if (cargoName) {
+        return { name: cargoName, source: 'Cargo.toml' };
+    }
+    // 4. Try go.mod
+    const goName = detectFromGoMod();
+    if (goName) {
+        return { name: goName, source: 'go.mod' };
+    }
+    // 5. Fallback to folder name
+    return { name: path.basename(process.cwd()), source: 'folder' };
+}
+/**
+ * Get the project name, initializing .agents/.env if needed
+ */
+function detectRepo() {
+    // 1. Check for PROJECT_NAME in .agents/.env
+    const env = readEnvConfig();
+    if (env.PROJECT_NAME) {
+        return env.PROJECT_NAME;
+    }
+    // 2. Detect from config files and auto-initialize
+    const detected = detectProjectName();
+    writeProjectName(detected.name, detected.source);
+    return detected.name;
+}
+/**
+ * Get project aliases for querying (includes current name and all aliases)
+ */
+function getProjectAliases() {
+    const env = readEnvConfig();
+    const projectName = env.PROJECT_NAME || detectRepo();
+    const folderName = path.basename(process.cwd());
+    const aliases = new Set();
+    aliases.add(projectName);
+    // Add explicit aliases from PROJECT_ALIASES
+    if (env.PROJECT_ALIASES) {
+        env.PROJECT_ALIASES.split(',').forEach(alias => {
+            const trimmed = alias.trim();
+            if (trimmed)
+                aliases.add(trimmed);
+        });
+    }
+    // Auto-include folder name if different from project name
+    if (folderName !== projectName) {
+        aliases.add(folderName);
+    }
+    return Array.from(aliases);
+}
+/**
+ * Get the env file path
+ */
+function getEnvPath() {
+    return path.join(process.cwd(), ENV_FILE);
+}
+function detectBranch() {
+    try {
+        const out = execSync('git rev-parse --abbrev-ref HEAD', { stdio: ['ignore', 'pipe', 'ignore'] });
+        return out.toString().trim();
+    }
+    catch (_err) {
+        return null;
+    }
+}
+function repoTags({ repo, branch } = {}) {
+    const tags = [];
+    if (repo)
+        tags.push(`repo:${repo}`);
+    if (branch)
+        tags.push(`branch:${branch}`);
+    return tags;
+}
+/**
+ * Generate repo tags for all aliases (for querying)
+ */
+function repoTagsWithAliases({ branch } = {}) {
+    const aliases = getProjectAliases();
+    return aliases.map(alias => repoTags({ repo: alias, branch }));
+}
+function getUserName() {
+    return process.env.USER || process.env.USERNAME || 'unknown';
+}
+module.exports = {
+    detectRepo,
+    detectBranch,
+    repoTags,
+    repoTagsWithAliases,
+    getProjectAliases,
+    getEnvPath,
+    getUserName,
+    readEnvConfig,
+    ENV_FILE,
+};