@rasensio/aidlc 0.1.0

package/dist/discover/scanner.js

@@ -0,0 +1,772 @@
+/**
+ * Codebase scanner for the AIDLC Discovery Engine.
+ *
+ * Static analysis only — no build, no execution (Req 15.7).
+ * Detects languages, frameworks, conventions and architecture.
+ * Writes Context_Docs to `.aidlc/context/`.
+ *
+ * Requirements: 15.1, 15.2, 15.5
+ */
+import { readFileSync, readdirSync, statSync, existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, extname, relative, basename } from 'node:path';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/** Extension-to-language mapping for detection. */
+const EXTENSION_MAP = {
+    '.ts': 'TypeScript',
+    '.tsx': 'TypeScript',
+    '.js': 'JavaScript',
+    '.jsx': 'JavaScript',
+    '.py': 'Python',
+    '.go': 'Go',
+    '.rs': 'Rust',
+    '.java': 'Java',
+    '.kt': 'Kotlin',
+    '.rb': 'Ruby',
+    '.php': 'PHP',
+    '.cs': 'C#',
+    '.cpp': 'C++',
+    '.cc': 'C++',
+    '.c': 'C',
+    '.h': 'C',
+    '.swift': 'Swift',
+    '.scala': 'Scala',
+    '.zig': 'Zig',
+    '.lua': 'Lua',
+    '.ex': 'Elixir',
+    '.exs': 'Elixir',
+    '.erl': 'Erlang',
+    '.hs': 'Haskell',
+    '.ml': 'OCaml',
+    '.dart': 'Dart',
+    '.r': 'R',
+    '.R': 'R',
+};
+/** Directories to always skip during scanning. */
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.hg',
+    '.svn',
+    'dist',
+    'build',
+    'out',
+    'target',
+    '.next',
+    '.nuxt',
+    '__pycache__',
+    '.venv',
+    'venv',
+    'vendor',
+    '.aidlc',
+    '.kiro',
+    '.claude',
+    '.cursor',
+    '.windsurf',
+    'coverage',
+]);
+/** Maximum files to walk (prevents runaway on monorepos). */
+const MAX_FILES = 10_000;
+/** Number of source files to sample for style inference. */
+const STYLE_SAMPLE_SIZE = 10;
+// ---------------------------------------------------------------------------
+// File walker (respects .gitignore patterns via SKIP_DIRS)
+// ---------------------------------------------------------------------------
+/**
+ * Walk a directory tree collecting file paths.
+ * Respects .gitignore by skipping common ignored directories.
+ * Static analysis only — no execution (Req 15.7).
+ */
+function walkFiles(root, gitignorePatterns) {
+    const files = [];
+    function walk(dir) {
+        if (files.length >= MAX_FILES)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (files.length >= MAX_FILES)
+                return;
+            const fullPath = join(dir, entry);
+            const rel = relative(root, fullPath);
+            // Skip hidden files/dirs (except known config files)
+            if (entry.startsWith('.') && !entry.startsWith('.env'))
+                continue;
+            let stat;
+            try {
+                stat = statSync(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                if (SKIP_DIRS.has(entry))
+                    continue;
+                if (matchesGitignore(rel, gitignorePatterns))
+                    continue;
+                walk(fullPath);
+            }
+            else if (stat.isFile()) {
+                if (matchesGitignore(rel, gitignorePatterns))
+                    continue;
+                files.push(fullPath);
+            }
+        }
+    }
+    walk(root);
+    return files;
+}
+/**
+ * Simple gitignore pattern matching (supports basic glob patterns).
+ * Returns true if the relative path matches any pattern.
+ */
+function matchesGitignore(relPath, patterns) {
+    for (const pattern of patterns) {
+        if (!pattern || pattern.startsWith('#'))
+            continue;
+        const trimmed = pattern.trim();
+        if (!trimmed)
+            continue;
+        // Simple prefix/suffix matching for common gitignore patterns
+        const normalized = trimmed.replace(/\/$/, '');
+        if (relPath === normalized)
+            return true;
+        if (relPath.startsWith(normalized + '/'))
+            return true;
+        // Handle wildcard patterns like *.log
+        if (normalized.startsWith('*')) {
+            const suffix = normalized.slice(1);
+            if (relPath.endsWith(suffix))
+                return true;
+            if (basename(relPath).endsWith(suffix))
+                return true;
+        }
+    }
+    return false;
+}
+/**
+ * Load .gitignore patterns from a project root.
+ */
+function loadGitignore(root) {
+    const gitignorePath = join(root, '.gitignore');
+    if (!existsSync(gitignorePath))
+        return [];
+    try {
+        return readFileSync(gitignorePath, 'utf8').split('\n');
+    }
+    catch {
+        return [];
+    }
+}
+// ---------------------------------------------------------------------------
+// Language detection
+// ---------------------------------------------------------------------------
+/**
+ * Count files by extension and map to language names.
+ * Returns sorted by file count descending.
+ */
+function detectLanguages(files) {
+    const counts = new Map();
+    for (const file of files) {
+        const ext = extname(file).toLowerCase();
+        const lang = EXTENSION_MAP[ext];
+        if (lang) {
+            counts.set(lang, (counts.get(lang) ?? 0) + 1);
+        }
+    }
+    const totalSource = Array.from(counts.values()).reduce((a, b) => a + b, 0);
+    if (totalSource === 0)
+        return [];
+    return Array.from(counts.entries())
+        .map(([name, fileCount]) => ({
+        name,
+        fileCount,
+        percentage: Math.round((fileCount / totalSource) * 100),
+    }))
+        .sort((a, b) => b.fileCount - a.fileCount);
+}
+const FRAMEWORK_DETECTORS = [
+    {
+        manifest: 'package.json',
+        detect: (content) => {
+            const found = [];
+            try {
+                const pkg = JSON.parse(content);
+                const allDeps = {
+                    ...pkg.dependencies,
+                    ...pkg.devDependencies,
+                };
+                found.push('Node.js');
+                const checks = [
+                    ['react', 'React'],
+                    ['next', 'Next.js'],
+                    ['express', 'Express'],
+                    ['fastify', 'Fastify'],
+                    ['vue', 'Vue'],
+                    ['@angular/core', 'Angular'],
+                    ['svelte', 'Svelte'],
+                    ['nuxt', 'Nuxt'],
+                    ['nestjs', 'NestJS'],
+                    ['@nestjs/core', 'NestJS'],
+                    ['hono', 'Hono'],
+                    ['astro', 'Astro'],
+                    ['remix', 'Remix'],
+                    ['@remix-run/node', 'Remix'],
+                    ['vite', 'Vite'],
+                    ['webpack', 'Webpack'],
+                    ['esbuild', 'esbuild'],
+                    ['tailwindcss', 'Tailwind CSS'],
+                    ['prisma', 'Prisma'],
+                    ['@prisma/client', 'Prisma'],
+                    ['drizzle-orm', 'Drizzle'],
+                    ['vitest', 'Vitest'],
+                    ['jest', 'Jest'],
+                    ['mocha', 'Mocha'],
+                ];
+                for (const [dep, name] of checks) {
+                    if (dep in allDeps)
+                        found.push(name);
+                }
+            }
+            catch {
+                // Invalid JSON — skip
+            }
+            return found;
+        },
+    },
+    {
+        manifest: 'pyproject.toml',
+        detect: (content) => {
+            const found = ['Python'];
+            const lower = content.toLowerCase();
+            if (lower.includes('django'))
+                found.push('Django');
+            if (lower.includes('flask'))
+                found.push('Flask');
+            if (lower.includes('fastapi'))
+                found.push('FastAPI');
+            if (lower.includes('pytest'))
+                found.push('pytest');
+            if (lower.includes('poetry'))
+                found.push('Poetry');
+            return found;
+        },
+    },
+    {
+        manifest: 'requirements.txt',
+        detect: (content) => {
+            const found = ['Python'];
+            const lower = content.toLowerCase();
+            if (lower.includes('django'))
+                found.push('Django');
+            if (lower.includes('flask'))
+                found.push('Flask');
+            if (lower.includes('fastapi'))
+                found.push('FastAPI');
+            return found;
+        },
+    },
+    {
+        manifest: 'go.mod',
+        detect: (_content) => ['Go'],
+    },
+    {
+        manifest: 'Cargo.toml',
+        detect: (content) => {
+            const found = ['Rust'];
+            const lower = content.toLowerCase();
+            if (lower.includes('actix'))
+                found.push('Actix');
+            if (lower.includes('tokio'))
+                found.push('Tokio');
+            if (lower.includes('axum'))
+                found.push('Axum');
+            return found;
+        },
+    },
+    {
+        manifest: 'pom.xml',
+        detect: (content) => {
+            const found = ['Java', 'Maven'];
+            const lower = content.toLowerCase();
+            if (lower.includes('spring'))
+                found.push('Spring');
+            return found;
+        },
+    },
+    {
+        manifest: 'build.gradle',
+        detect: (content) => {
+            const found = ['Gradle'];
+            const lower = content.toLowerCase();
+            if (lower.includes('kotlin'))
+                found.push('Kotlin');
+            else
+                found.push('Java');
+            if (lower.includes('spring'))
+                found.push('Spring');
+            return found;
+        },
+    },
+];
+/**
+ * Detect frameworks by checking for manifest files at the project root.
+ */
+function detectFrameworks(root) {
+    const found = new Set();
+    for (const detector of FRAMEWORK_DETECTORS) {
+        const manifestPath = join(root, detector.manifest);
+        if (!existsSync(manifestPath))
+            continue;
+        try {
+            const content = readFileSync(manifestPath, 'utf8');
+            for (const fw of detector.detect(content)) {
+                found.add(fw);
+            }
+        }
+        catch {
+            // Skip unreadable manifests
+        }
+    }
+    return Array.from(found).sort();
+}
+// ---------------------------------------------------------------------------
+// Style inference (sampled)
+// ---------------------------------------------------------------------------
+/** Source file extensions to consider for style analysis. */
+const SOURCE_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.py', '.go', '.rs', '.java', '.kt', '.rb',
+]);
+/**
+ * Infer code style conventions from a sample of source files.
+ * Analyzes indentation, naming, and import patterns.
+ */
+function inferConventions(files, root) {
+    // Select first N source files for sampling
+    const sourceFiles = files
+        .filter((f) => SOURCE_EXTENSIONS.has(extname(f).toLowerCase()))
+        .slice(0, STYLE_SAMPLE_SIZE);
+    if (sourceFiles.length === 0) {
+        return { indentation: 'unknown', naming: 'unknown', importStyle: 'unknown' };
+    }
+    const indentCounts = { twoSpace: 0, fourSpace: 0, tab: 0 };
+    const namingCounts = { camelCase: 0, snake_case: 0, PascalCase: 0 };
+    let groupedImports = 0;
+    let ungroupedImports = 0;
+    for (const filePath of sourceFiles) {
+        let content;
+        try {
+            content = readFileSync(filePath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const lines = content.split('\n');
+        analyzeIndentation(lines, indentCounts);
+        analyzeNaming(content, namingCounts);
+        analyzeImports(lines, filePath, (grouped) => {
+            if (grouped)
+                groupedImports++;
+            else
+                ungroupedImports++;
+        });
+    }
+    return {
+        indentation: resolveIndentation(indentCounts),
+        naming: resolveNaming(namingCounts),
+        importStyle: groupedImports > ungroupedImports ? 'grouped' : 'ungrouped',
+    };
+}
+function analyzeIndentation(lines, counts) {
+    for (const line of lines) {
+        if (!line || line.trim() === '')
+            continue;
+        const match = line.match(/^(\s+)/);
+        if (!match)
+            continue;
+        const indent = match[1];
+        if (indent.includes('\t')) {
+            counts.tab++;
+        }
+        else if (indent.length % 4 === 0) {
+            counts.fourSpace++;
+        }
+        else if (indent.length % 2 === 0) {
+            counts.twoSpace++;
+        }
+    }
+}
+function analyzeNaming(content, counts) {
+    // Look for variable/function declarations
+    const camelRe = /\b(?:const|let|var|function)\s+([a-z][a-zA-Z0-9]*[A-Z][a-zA-Z0-9]*)\b/g;
+    const snakeRe = /\b(?:const|let|var|function|def)\s+([a-z][a-z0-9]*_[a-z0-9_]*)\b/g;
+    const pascalRe = /\b(?:class|interface|type|struct|enum)\s+([A-Z][a-zA-Z0-9]+)\b/g;
+    let match;
+    while ((match = camelRe.exec(content)) !== null) {
+        if (match[1])
+            counts.camelCase++;
+    }
+    while ((match = snakeRe.exec(content)) !== null) {
+        if (match[1])
+            counts.snake_case++;
+    }
+    while ((match = pascalRe.exec(content)) !== null) {
+        if (match[1])
+            counts.PascalCase++;
+    }
+}
+function analyzeImports(lines, filePath, report) {
+    const ext = extname(filePath).toLowerCase();
+    const importLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith('import ') ||
+            line.startsWith('from ') ||
+            (ext === '.py' && line.match(/^(?:import|from)\s/))) {
+            importLines.push(i);
+        }
+    }
+    if (importLines.length < 3)
+        return;
+    // Check for blank lines between import groups (indicates grouping)
+    let hasGap = false;
+    for (let i = 1; i < importLines.length; i++) {
+        const diff = importLines[i] - importLines[i - 1];
+        if (diff > 1) {
+            // Check if the gap contains a blank line
+            for (let j = importLines[i - 1] + 1; j < importLines[i]; j++) {
+                if (lines[j]?.trim() === '') {
+                    hasGap = true;
+                    break;
+                }
+            }
+        }
+        if (hasGap)
+            break;
+    }
+    report(hasGap);
+}
+function resolveIndentation(counts) {
+    const max = Math.max(counts.twoSpace, counts.fourSpace, counts.tab);
+    if (max === 0)
+        return 'unknown';
+    if (counts.tab === max)
+        return 'tabs';
+    if (counts.fourSpace === max)
+        return '4-space';
+    return '2-space';
+}
+function resolveNaming(counts) {
+    const max = Math.max(counts.camelCase, counts.snake_case, counts.PascalCase);
+    if (max === 0)
+        return 'unknown';
+    if (counts.snake_case === max)
+        return 'snake_case';
+    if (counts.PascalCase === max)
+        return 'PascalCase';
+    return 'camelCase';
+}
+// ---------------------------------------------------------------------------
+// Architecture inference
+// ---------------------------------------------------------------------------
+/** Known directory role patterns. */
+const DIR_ROLES = [
+    [/^src$/i, 'source'],
+    [/^lib$/i, 'library'],
+    [/^test(s)?$/i, 'tests'],
+    [/^spec(s)?$/i, 'tests'],
+    [/^__tests__$/i, 'tests'],
+    [/^doc(s)?$/i, 'documentation'],
+    [/^config$/i, 'configuration'],
+    [/^scripts?$/i, 'scripts'],
+    [/^bin$/i, 'binaries'],
+    [/^public$/i, 'static assets'],
+    [/^static$/i, 'static assets'],
+    [/^assets$/i, 'assets'],
+    [/^components?$/i, 'components'],
+    [/^pages?$/i, 'pages/routes'],
+    [/^api$/i, 'API layer'],
+    [/^routes?$/i, 'routes'],
+    [/^middleware$/i, 'middleware'],
+    [/^models?$/i, 'models/data'],
+    [/^services?$/i, 'services'],
+    [/^utils?$/i, 'utilities'],
+    [/^helpers?$/i, 'helpers'],
+    [/^types?$/i, 'type definitions'],
+    [/^styles?$/i, 'styles'],
+    [/^migrations?$/i, 'database migrations'],
+];
+/**
+ * Infer architecture from directory structure and file presence.
+ */
+function inferArchitecture(root, files) {
+    // Detect directory roles from top-level directories
+    const topDirs = getTopLevelDirs(root);
+    const roles = [];
+    for (const dir of topDirs) {
+        for (const [pattern, role] of DIR_ROLES) {
+            if (pattern.test(dir)) {
+                roles.push(`${dir}/ → ${role}`);
+                break;
+            }
+        }
+    }
+    const structure = roles.length > 0
+        ? roles.join(', ')
+        : 'flat structure';
+    // Detect entry points
+    const entryPoints = detectEntryPoints(root, files);
+    // Detect config approach
+    const configApproach = detectConfigApproach(root);
+    return { structure, entryPoints, configApproach };
+}
+function getTopLevelDirs(root) {
+    try {
+        return readdirSync(root)
+            .filter((entry) => {
+            if (entry.startsWith('.'))
+                return false;
+            if (SKIP_DIRS.has(entry))
+                return false;
+            try {
+                return statSync(join(root, entry)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function detectEntryPoints(root, files) {
+    const entryPoints = [];
+    // Check package.json for main/bin entries
+    const pkgPath = join(root, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+            if (pkg.main)
+                entryPoints.push(pkg.main);
+            if (typeof pkg.bin === 'string') {
+                entryPoints.push(pkg.bin);
+            }
+            else if (pkg.bin && typeof pkg.bin === 'object') {
+                entryPoints.push(...Object.values(pkg.bin));
+            }
+        }
+        catch {
+            // skip
+        }
+    }
+    // Common entry point file names
+    const commonEntries = [
+        'index.ts', 'index.js', 'main.ts', 'main.js',
+        'app.ts', 'app.js', 'server.ts', 'server.js',
+        'main.py', 'app.py', 'manage.py',
+        'main.go', 'cmd/main.go',
+        'main.rs', 'src/main.rs', 'src/lib.rs',
+    ];
+    for (const entry of commonEntries) {
+        const fullPath = join(root, entry);
+        if (existsSync(fullPath)) {
+            if (!entryPoints.includes(entry)) {
+                entryPoints.push(entry);
+            }
+        }
+    }
+    // Also check for entry points in found files at src/ root
+    for (const file of files) {
+        const rel = relative(root, file);
+        if (rel.match(/^src\/(?:index|main|app|cli)\.[tj]s$/)) {
+            if (!entryPoints.includes(rel)) {
+                entryPoints.push(rel);
+            }
+        }
+    }
+    return entryPoints.slice(0, 10); // Cap to avoid excessive output
+}
+function detectConfigApproach(root) {
+    const approaches = [];
+    const configFiles = [
+        ['.env', 'environment variables (.env)'],
+        ['.env.example', 'environment variables (.env)'],
+        ['config.yaml', 'YAML configuration'],
+        ['config.yml', 'YAML configuration'],
+        ['config.json', 'JSON configuration'],
+        ['tsconfig.json', 'TypeScript config'],
+        ['webpack.config.js', 'Webpack'],
+        ['vite.config.ts', 'Vite'],
+        ['vite.config.js', 'Vite'],
+        ['vitest.config.ts', 'Vitest'],
+        ['eslint.config.js', 'ESLint'],
+        ['.eslintrc.json', 'ESLint'],
+        ['.eslintrc.js', 'ESLint'],
+        ['prettier.config.js', 'Prettier'],
+        ['.prettierrc', 'Prettier'],
+        ['docker-compose.yml', 'Docker Compose'],
+        ['Dockerfile', 'Docker'],
+    ];
+    const seen = new Set();
+    for (const [file, approach] of configFiles) {
+        if (existsSync(join(root, file)) && !seen.has(approach)) {
+            seen.add(approach);
+            approaches.push(approach);
+        }
+    }
+    if (approaches.length === 0)
+        return 'none detected';
+    return approaches.join(', ');
+}
+// ---------------------------------------------------------------------------
+// Main scanner
+// ---------------------------------------------------------------------------
+/**
+ * Scan a codebase and produce a structured scan result.
+ * Static analysis only — no build, no execution (Req 15.7).
+ *
+ * @param projectRoot - Absolute path to the project root.
+ * @returns Structured scan result with languages, frameworks, conventions, and architecture.
+ */
+export function scanCodebase(projectRoot) {
+    const gitignorePatterns = loadGitignore(projectRoot);
+    const files = walkFiles(projectRoot, gitignorePatterns);
+    const languages = detectLanguages(files);
+    const frameworks = detectFrameworks(projectRoot);
+    const conventions = inferConventions(files, projectRoot);
+    const architecture = inferArchitecture(projectRoot, files);
+    return {
+        languages,
+        frameworks,
+        conventions,
+        architecture,
+        filesScanned: files.length,
+    };
+}
+// ---------------------------------------------------------------------------
+// Output renderers
+// ---------------------------------------------------------------------------
+/**
+ * Render a style-guide.md Context_Doc from scan results.
+ * Includes `generated_by: aidlc-discover` frontmatter.
+ */
+export function renderStyleGuide(result) {
+    const lines = [
+        '---',
+        'generated_by: aidlc-discover',
+        '---',
+        '',
+        '# Style Guide',
+        '',
+        '## Languages',
+        '',
+    ];
+    if (result.languages.length > 0) {
+        lines.push('| Language | Files | Percentage |');
+        lines.push('|----------|-------|------------|');
+        for (const lang of result.languages) {
+            lines.push(`| ${lang.name} | ${lang.fileCount} | ${lang.percentage}% |`);
+        }
+    }
+    else {
+        lines.push('No source files detected.');
+    }
+    lines.push('');
+    lines.push('## Conventions');
+    lines.push('');
+    lines.push(`- **Indentation**: ${result.conventions.indentation}`);
+    lines.push(`- **Naming convention**: ${result.conventions.naming}`);
+    lines.push(`- **Import style**: ${result.conventions.importStyle}`);
+    lines.push('');
+    lines.push('## Frameworks & Tools');
+    lines.push('');
+    if (result.frameworks.length > 0) {
+        for (const fw of result.frameworks) {
+            lines.push(`- ${fw}`);
+        }
+    }
+    else {
+        lines.push('No frameworks detected.');
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Render an architecture.md Context_Doc from scan results.
+ * Includes `generated_by: aidlc-discover` frontmatter.
+ */
+export function renderArchitectureDoc(result) {
+    const lines = [
+        '---',
+        'generated_by: aidlc-discover',
+        '---',
+        '',
+        '# Architecture Overview',
+        '',
+        '## Tech Stack',
+        '',
+    ];
+    if (result.languages.length > 0) {
+        const primary = result.languages.slice(0, 3).map((l) => l.name);
+        lines.push(`Primary language(s): ${primary.join(', ')}`);
+    }
+    if (result.frameworks.length > 0) {
+        lines.push(`Frameworks/tools: ${result.frameworks.join(', ')}`);
+    }
+    lines.push('');
+    lines.push('## Directory Structure');
+    lines.push('');
+    lines.push(`Layout: ${result.architecture.structure}`);
+    lines.push('');
+    lines.push('## Entry Points');
+    lines.push('');
+    if (result.architecture.entryPoints.length > 0) {
+        for (const ep of result.architecture.entryPoints) {
+            lines.push(`- \`${ep}\``);
+        }
+    }
+    else {
+        lines.push('No entry points detected.');
+    }
+    lines.push('');
+    lines.push('## Configuration');
+    lines.push('');
+    lines.push(`Approach: ${result.architecture.configApproach}`);
+    lines.push('');
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// Write Context_Docs to disk
+// ---------------------------------------------------------------------------
+/**
+ * Write generated Context_Docs to `.aidlc/context/`.
+ * Creates the directory if it doesn't exist.
+ * Total output ≤ 100KB, ≤ 10 files (Req 15.5, 17.2).
+ *
+ * @param projectRoot - Absolute path to the project root.
+ * @param result - Scan result to render.
+ * @returns Paths of written files relative to projectRoot.
+ */
+export function writeContextDocs(projectRoot, result) {
+    const contextDir = join(projectRoot, '.aidlc', 'context');
+    mkdirSync(contextDir, { recursive: true });
+    const styleGuide = renderStyleGuide(result);
+    const architectureDoc = renderArchitectureDoc(result);
+    const stylePath = join(contextDir, 'style-guide.md');
+    const archPath = join(contextDir, 'architecture.md');
+    writeFileSync(stylePath, styleGuide, 'utf8');
+    writeFileSync(archPath, architectureDoc, 'utf8');
+    return [
+        '.aidlc/context/style-guide.md',
+        '.aidlc/context/architecture.md',
+    ];
+}
+//# sourceMappingURL=scanner.js.map