@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/lint/loader.js

@@ -0,0 +1,225 @@
+/**
+ * Lint Rule Loader
+ *
+ * Discovers and loads lint rulesets from installed frameworks.
+ * Each framework ships a `lint/` directory with a `ruleset.yaml`
+ * and individual rule YAML files.
+ *
+ * @issue #810
+ */
+import fs from 'fs';
+import fsp from 'fs/promises';
+import path from 'path';
+import { projectAiwgPath } from '../config/project-artifacts.js';
+/**
+ * Parse YAML frontmatter-style content (simple key: value parser)
+ * Handles the subset of YAML used in lint rule definitions.
+ */
+function parseSimpleYaml(content) {
+    const result = {};
+    const lines = content.split('\n');
+    let currentKey = '';
+    let currentArray = null;
+    let currentObject = null;
+    let inChecks = false;
+    for (const line of lines) {
+        const trimmed = line.trimEnd();
+        // Skip comments and empty lines
+        if (trimmed === '' || trimmed.startsWith('#'))
+            continue;
+        // Top-level key: value
+        const topMatch = trimmed.match(/^(\w[\w-]*)\s*:\s*(.*)$/);
+        if (topMatch && !trimmed.startsWith('  ')) {
+            // Flush any pending array
+            if (currentArray && currentKey) {
+                result[currentKey] = currentArray;
+                currentArray = null;
+            }
+            currentKey = topMatch[1];
+            const value = topMatch[2].trim();
+            if (value === '') {
+                // Could be start of a nested structure
+                if (currentKey === 'checks') {
+                    inChecks = true;
+                    currentArray = [];
+                }
+                else if (currentKey === 'applies-to') {
+                    currentObject = {};
+                    result[currentKey] = currentObject;
+                }
+            }
+            else {
+                inChecks = false;
+                result[currentKey] = parseValue(value);
+            }
+            continue;
+        }
+        // Nested key under applies-to
+        if (currentObject && trimmed.match(/^\s{2}\w/)) {
+            const nestedMatch = trimmed.match(/^\s{2}(\w[\w-]*)\s*:\s*(.+)$/);
+            if (nestedMatch) {
+                currentObject[nestedMatch[1]] = parseValue(nestedMatch[2].trim());
+                continue;
+            }
+        }
+        // Array item in checks
+        if (inChecks && trimmed.match(/^\s{2}-\s/)) {
+            currentObject = {};
+            if (currentArray)
+                currentArray.push(currentObject);
+            const itemMatch = trimmed.match(/^\s{2}-\s+(\w[\w-]*)\s*:\s*(.+)$/);
+            if (itemMatch) {
+                currentObject[itemMatch[1]] = parseValue(itemMatch[2].trim());
+            }
+            continue;
+        }
+        // Properties of current check item
+        if (inChecks && currentObject && trimmed.match(/^\s{4}\w/)) {
+            const propMatch = trimmed.match(/^\s{4}(\w[\w-]*)\s*:\s*(.+)$/);
+            if (propMatch) {
+                const val = propMatch[2].trim();
+                // Handle inline arrays: [field1, field2, field3]
+                if (val.startsWith('[') && val.endsWith(']')) {
+                    currentObject[propMatch[1]] = val
+                        .slice(1, -1)
+                        .split(',')
+                        .map((s) => s.trim());
+                }
+                else {
+                    currentObject[propMatch[1]] = parseValue(val);
+                }
+                continue;
+            }
+        }
+    }
+    // Flush trailing array
+    if (currentArray && currentKey) {
+        result[currentKey] = currentArray;
+    }
+    return result;
+}
+function parseValue(val) {
+    // Boolean
+    if (val === 'true')
+        return true;
+    if (val === 'false')
+        return false;
+    // Number
+    if (/^\d+(\.\d+)?$/.test(val))
+        return Number(val);
+    // Inline array
+    if (val.startsWith('[') && val.endsWith(']')) {
+        return val
+            .slice(1, -1)
+            .split(',')
+            .map(s => s.trim().replace(/^["']|["']$/g, ''));
+    }
+    // Strip quotes and unescape YAML double-quote sequences
+    const unquoted = val.replace(/^["']|["']$/g, '');
+    return unquoted.replace(/\\\\/g, '\\');
+}
+/**
+ * Load a single lint rule from a YAML file
+ */
+export async function loadRule(filePath) {
+    const content = await fsp.readFile(filePath, 'utf8');
+    const parsed = parseSimpleYaml(content);
+    const appliesTo = parsed['applies-to'];
+    return {
+        id: String(parsed.id || ''),
+        name: String(parsed.name || ''),
+        description: String(parsed.description || ''),
+        severity: parsed.severity || 'warn',
+        appliesTo: {
+            glob: appliesTo?.glob || '**/*',
+        },
+        checks: parsed.checks || [],
+    };
+}
+/**
+ * Load a ruleset and all its rules from a framework's lint/ directory
+ */
+export async function loadRuleset(lintDir, frameworkId) {
+    const rulesetPath = path.join(lintDir, 'ruleset.yaml');
+    if (!fs.existsSync(rulesetPath))
+        return null;
+    const content = await fsp.readFile(rulesetPath, 'utf8');
+    const parsed = parseSimpleYaml(content);
+    // Load individual rule files
+    const rules = [];
+    const entries = await fsp.readdir(lintDir);
+    for (const entry of entries) {
+        if (entry === 'ruleset.yaml')
+            continue;
+        if (!entry.endsWith('.yaml') && !entry.endsWith('.yml'))
+            continue;
+        try {
+            const rule = await loadRule(path.join(lintDir, entry));
+            rules.push(rule);
+        }
+        catch {
+            // Skip malformed rule files
+        }
+    }
+    return {
+        id: String(parsed.id || frameworkId),
+        name: String(parsed.name || frameworkId),
+        description: String(parsed.description || ''),
+        framework: frameworkId,
+        version: String(parsed.version || '1.0.0'),
+        rules,
+    };
+}
+/**
+ * Discover all available rulesets from installed frameworks
+ *
+ * Looks in two locations:
+ * 1. Framework source: agentic/code/frameworks/{id}/lint/
+ * 2. Deployed frameworks: .aiwg/frameworks/{id}/lint/
+ */
+export async function discoverRulesets(cwd, frameworkRoot) {
+    const rulesets = [];
+    // Check framework source directories
+    const frameworksDir = path.join(frameworkRoot, 'agentic', 'code', 'frameworks');
+    if (fs.existsSync(frameworksDir)) {
+        try {
+            const frameworks = await fsp.readdir(frameworksDir);
+            for (const fw of frameworks) {
+                const lintDir = path.join(frameworksDir, fw, 'lint');
+                if (fs.existsSync(lintDir)) {
+                    const ruleset = await loadRuleset(lintDir, fw);
+                    if (ruleset)
+                        rulesets.push(ruleset);
+                }
+            }
+        }
+        catch {
+            // Skip on error
+        }
+    }
+    // Also check .aiwg/frameworks/ for deployed rulesets
+    const deployedDir = projectAiwgPath(cwd, 'frameworks');
+    if (fs.existsSync(deployedDir)) {
+        try {
+            const frameworks = await fsp.readdir(deployedDir);
+            for (const fw of frameworks) {
+                if (fw === 'registry.json')
+                    continue;
+                const lintDir = path.join(deployedDir, fw, 'lint');
+                if (fs.existsSync(lintDir)) {
+                    // Skip if already loaded from source
+                    if (!rulesets.find(r => r.id === fw)) {
+                        const ruleset = await loadRuleset(lintDir, fw);
+                        if (ruleset)
+                            rulesets.push(ruleset);
+                    }
+                }
+            }
+        }
+        catch {
+            // Skip on error
+        }
+    }
+    return rulesets;
+}
+//# sourceMappingURL=loader.js.map

package/dist/src/lint/reporters.js

@@ -0,0 +1,141 @@
+/**
+ * Lint Result Reporters
+ *
+ * Format lint results for terminal output, JSON export, and summary views.
+ *
+ * @issue #810
+ */
+const SEVERITY_ICONS = {
+    error: '\u2718', // ✘
+    warn: '\u26A0', // ⚠
+    info: '\u2139', // ℹ
+};
+const SEVERITY_COLORS = {
+    error: '\x1b[31m', // red
+    warn: '\x1b[33m', // yellow
+    info: '\x1b[36m', // cyan
+};
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+/**
+ * Format a single diagnostic line
+ */
+function formatDiagnostic(d) {
+    const icon = SEVERITY_ICONS[d.severity] || '?';
+    const color = SEVERITY_COLORS[d.severity] || '';
+    const lineRef = d.line ? `:${d.line}` : '';
+    const fixHint = d.fix ? `${DIM}  fix: ${d.fix}${RESET}` : '';
+    return `  ${color}${icon}${RESET} ${d.file}${lineRef}: ${d.message} ${DIM}[${d.ruleId}]${RESET}${fixHint}`;
+}
+/**
+ * Format lint results in full detail
+ */
+function formatFull(result) {
+    const lines = [];
+    lines.push(`${BOLD}AIWG Lint${RESET}`);
+    lines.push(`Target: ${result.target}`);
+    lines.push(`Rulesets: ${result.rulesets.join(', ')}`);
+    lines.push(`Files checked: ${result.summary.filesChecked}`);
+    lines.push('');
+    if (result.diagnostics.length === 0) {
+        lines.push('\x1b[32m\u2714 No issues found\x1b[0m');
+    }
+    else {
+        // Group by file
+        const byFile = new Map();
+        for (const d of result.diagnostics) {
+            const list = byFile.get(d.file) || [];
+            list.push(d);
+            byFile.set(d.file, list);
+        }
+        for (const [file, diagnostics] of byFile) {
+            lines.push(`${BOLD}${file}${RESET}`);
+            for (const d of diagnostics) {
+                lines.push(formatDiagnostic(d));
+            }
+            lines.push('');
+        }
+    }
+    // Summary line
+    const parts = [];
+    if (result.summary.errors > 0) {
+        parts.push(`\x1b[31m${result.summary.errors} error(s)\x1b[0m`);
+    }
+    if (result.summary.warnings > 0) {
+        parts.push(`\x1b[33m${result.summary.warnings} warning(s)\x1b[0m`);
+    }
+    if (result.summary.infos > 0) {
+        parts.push(`\x1b[36m${result.summary.infos} info(s)\x1b[0m`);
+    }
+    if (parts.length > 0) {
+        lines.push(parts.join(', '));
+    }
+    const statusIcon = result.summary.passed ? '\x1b[32m\u2714 PASS\x1b[0m' : '\x1b[31m\u2718 FAIL\x1b[0m';
+    lines.push(`\nResult: ${statusIcon}`);
+    return lines.join('\n');
+}
+/**
+ * Format lint results as a summary (counts only)
+ */
+function formatSummary(result) {
+    const lines = [];
+    lines.push(`Lint: ${result.summary.filesChecked} files, ${result.summary.errors} errors, ${result.summary.warnings} warnings, ${result.summary.infos} info`);
+    const statusIcon = result.summary.passed ? '\u2714 PASS' : '\u2718 FAIL';
+    lines.push(`Result: ${statusIcon}`);
+    return lines.join('\n');
+}
+/**
+ * Format lint results as JSON
+ */
+function formatJson(result) {
+    return JSON.stringify(result, null, 2);
+}
+/**
+ * Format lint result in the requested output format
+ */
+export function formatResult(result, format) {
+    switch (format) {
+        case 'json':
+            return formatJson(result);
+        case 'summary':
+            return formatSummary(result);
+        case 'full':
+        default:
+            return formatFull(result);
+    }
+}
+/**
+ * Format a list of available rulesets
+ */
+export function formatRulesetList(rulesets) {
+    if (rulesets.length === 0) {
+        return 'No lint rulesets found. Install a framework with lint rules (e.g., aiwg use research).';
+    }
+    const lines = [];
+    lines.push(`${BOLD}Available Lint Rulesets${RESET}\n`);
+    for (const rs of rulesets) {
+        lines.push(`  ${BOLD}${rs.id}${RESET} (${rs.framework})`);
+        lines.push(`    ${rs.description}`);
+        lines.push(`    ${rs.rules.length} rule(s), v${rs.version}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Format the rules within a ruleset
+ */
+export function formatRuleList(ruleset) {
+    const lines = [];
+    lines.push(`${BOLD}Rules in '${ruleset.id}' (${ruleset.framework})${RESET}\n`);
+    for (const rule of ruleset.rules) {
+        const icon = SEVERITY_ICONS[rule.severity] || '?';
+        const color = SEVERITY_COLORS[rule.severity] || '';
+        lines.push(`  ${color}${icon}${RESET} ${BOLD}${rule.id}${RESET} [${rule.severity}]`);
+        lines.push(`    ${rule.description}`);
+        lines.push(`    applies to: ${rule.appliesTo.glob}`);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=reporters.js.map