@pugi/cli 0.1.0-beta.21 → 0.1.0-beta.23

package/dist/core/repl/codebase-survey.js

@@ -1,308 +0,0 @@
-/**
- * Codebase survey for the `/init` interview - Phase 2.
- *
- * Inspired by Claude Code's /init Phase 2 (the upstream spawns a
- * Task-tool subagent to read manifest files + CI config + existing
- * agent rules and produce a structured "what this repo is" digest).
- * Independent implementation: Pugi's subagent infra is admin-api
- * scheduled and not available in the local REPL boot path, so the
- * survey runs as a direct filesystem scan instead. The shape of the
- * output matches the upstream pattern - manifest, languages, build /
- * test / lint commands, existing AI-tool configs - so the downstream
- * Phase 3 / Phase 4 logic stays portable.
- *
- * # Design notes
- *
- * - Pure fs reads. No spawn, no network, no LLM call. Safe to run on
- *   every `/init` invocation without rate-limit concern.
- * - Bounded: every read caps at 16 KB to defend against an enormous
- *   manifest pinning memory. Real package.json / pyproject.toml are
- *   well under that.
- * - Defensive: a missing or unreadable file maps to `undefined` in the
- *   returned record. Phase 3 treats unknowns as "ask the operator".
- * - Manifest grammar is closed: package.json (Node) and pyproject.toml
- *   (Python) are recognised explicitly because Pugi customers ship one
- *   of those nine times out of ten. Cargo.toml / go.mod / pom.xml are
- *   detected by filename only - we surface "rust"/"go"/"java" as the
- *   language hint but do not parse them, because the Phase 3 question
- *   set asks for build commands directly when the manifest is opaque.
- *
- * # What we collect
- *
- *   1. `manifest`: which manifest file was found (closed enum).
- *   2. `languages`: deduped list inferred from manifest + file extension
- *      heuristics under the workspace root (one-level deep scan).
- *   3. `packageManager`: pnpm / npm / yarn (Node only) or `unknown`.
- *   4. `buildCommand` / `testCommand` / `lintCommand`: parsed out of
- *      `package.json` scripts when a Node manifest is present.
- *   5. `aiToolConfigs`: a record of which sibling-agent config files
- *      already exist (CLAUDE.md, AGENTS.md, .cursorrules,
- *      .github/copilot-instructions.md, .windsurfrules, .clinerules,
- *      .mcp.json). Phase 4 mines these for "important parts" without
- *      duplicating them into PUGI.md.
- *   6. `hasReadme`, `hasGit`, `hasCi`: simple booleans for the
- *      gap-question logic.
- *   7. `hasExistingPugiMd`: true when re-running `/init` against a
- *      workspace that already produced PUGI.md.
- *
- * # Why not spawn a Pugi subagent
- *
- * The Pugi subagent dispatcher (apps/pugi-cli/src/core/subagents/)
- * speaks to admin-api over the SSE transport. Running the codebase
- * survey through that path would (a) burn a tenant token quota on
- * every `/init`, (b) require an online connection, and (c) round-trip
- * structured data through the persona prompt - which is the wrong
- * tool for "list which files exist". A direct fs scan is faster,
- * deterministic, and works offline. The upstream Task-tool decision
- * makes sense in a hosted product where every operation is metered;
- * Pugi runs locally so we keep the survey local too.
- */
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-/**
- * Maximum bytes the survey reads from any single file. Real manifests
- * are tiny (<8 KB); this cap defends against a hostile or accidental
- * gigabyte JSON pinning the REPL boot.
- */
-const MAX_READ_BYTES = 16 * 1024;
-/**
- * Top-level directory scan budget. The survey looks at the workspace
- * root + at most this many entries when inferring languages from file
- * extensions. Deep walks are not needed - the manifest is the source
- * of truth for the active stack.
- */
-const MAX_TOP_LEVEL_ENTRIES = 200;
-/**
- * Run a codebase survey against `workspaceRoot`. Pure: returns a
- * snapshot record; the caller decides how to render it.
- */
-export function surveyCodebase(workspaceRoot) {
-    const errors = [];
-    const manifest = detectManifest(workspaceRoot);
-    const packageJson = manifest === 'package.json'
-        ? safeReadJson(join(workspaceRoot, 'package.json'), errors)
-        : undefined;
-    const packageManager = inferPackageManager(workspaceRoot, packageJson);
-    const languages = inferLanguages(workspaceRoot, manifest, errors);
-    const scripts = (packageJson && typeof packageJson === 'object' && packageJson !== null
-        ? packageJson.scripts
-        : undefined) ?? {};
-    const buildCommand = pickScript(scripts, ['build', 'compile']);
-    const testCommand = pickScript(scripts, ['test', 'tests']);
-    const lintCommand = pickScript(scripts, ['lint', 'check']);
-    const formatCommand = pickScript(scripts, ['format', 'fmt', 'prettier']);
-    const aiToolConfigs = scanAiToolConfigs(workspaceRoot);
-    return {
-        workspaceRoot,
-        manifest,
-        packageManager,
-        languages,
-        buildCommand,
-        testCommand,
-        lintCommand,
-        formatCommand,
-        aiToolConfigs,
-        hasReadme: existsSafe(join(workspaceRoot, 'README.md')) ||
-            existsSafe(join(workspaceRoot, 'readme.md')),
-        hasGit: existsSafe(join(workspaceRoot, '.git')),
-        hasCi: detectCi(workspaceRoot),
-        hasExistingPugiMd: aiToolConfigs['PUGI.md'],
-        readErrors: errors,
-    };
-}
-/* ------------------------------------------------------------------ */
-/* Manifest detection                                                  */
-/* ------------------------------------------------------------------ */
-const MANIFEST_PROBE_ORDER = Object.freeze([
-    'package.json',
-    'pyproject.toml',
-    'Cargo.toml',
-    'go.mod',
-    'pom.xml',
-    'Gemfile',
-    'composer.json',
-]);
-function detectManifest(root) {
-    for (const candidate of MANIFEST_PROBE_ORDER) {
-        if (existsSafe(join(root, candidate)))
-            return candidate;
-    }
-    return 'unknown';
-}
-function inferPackageManager(root, packageJson) {
-    // package.json `packageManager` field wins when present (corepack convention).
-    if (packageJson &&
-        typeof packageJson === 'object' &&
-        packageJson !== null &&
-        'packageManager' in packageJson) {
-        const declared = packageJson.packageManager;
-        if (typeof declared === 'string') {
-            if (declared.startsWith('pnpm@'))
-                return 'pnpm';
-            if (declared.startsWith('yarn@'))
-                return 'yarn';
-            if (declared.startsWith('npm@'))
-                return 'npm';
-            if (declared.startsWith('bun@'))
-                return 'bun';
-        }
-    }
-    // Lockfile fallback.
-    if (existsSafe(join(root, 'pnpm-lock.yaml')))
-        return 'pnpm';
-    if (existsSafe(join(root, 'yarn.lock')))
-        return 'yarn';
-    if (existsSafe(join(root, 'bun.lockb')) || existsSafe(join(root, 'bun.lock')))
-        return 'bun';
-    if (existsSafe(join(root, 'package-lock.json')))
-        return 'npm';
-    return 'unknown';
-}
-/* ------------------------------------------------------------------ */
-/* Language inference                                                  */
-/* ------------------------------------------------------------------ */
-const EXT_TO_LANG = Object.freeze({
-    '.ts': 'typescript',
-    '.tsx': 'typescript',
-    '.js': 'javascript',
-    '.jsx': 'javascript',
-    '.mjs': 'javascript',
-    '.cjs': 'javascript',
-    '.py': 'python',
-    '.rs': 'rust',
-    '.go': 'go',
-    '.java': 'java',
-    '.kt': 'kotlin',
-    '.swift': 'swift',
-    '.rb': 'ruby',
-    '.php': 'php',
-    '.cs': 'csharp',
-    '.cpp': 'cpp',
-    '.c': 'c',
-});
-const MANIFEST_TO_LANG = Object.freeze({
-    'package.json': ['javascript'],
-    'pyproject.toml': ['python'],
-    'Cargo.toml': ['rust'],
-    'go.mod': ['go'],
-    'pom.xml': ['java'],
-    'Gemfile': ['ruby'],
-    'composer.json': ['php'],
-    'unknown': [],
-});
-function inferLanguages(root, manifest, errors) {
-    const collected = new Set(MANIFEST_TO_LANG[manifest]);
-    // Top-level extension scan, bounded.
-    try {
-        const entries = readdirSync(root);
-        let scanned = 0;
-        for (const entry of entries) {
-            if (scanned >= MAX_TOP_LEVEL_ENTRIES)
-                break;
-            scanned += 1;
-            // Skip dotfiles + common dependency dirs - they pollute the
-            // language inference with build/cache content.
-            if (entry.startsWith('.') || entry === 'node_modules' || entry === 'dist')
-                continue;
-            const dot = entry.lastIndexOf('.');
-            if (dot <= 0)
-                continue;
-            const ext = entry.slice(dot);
-            const lang = EXT_TO_LANG[ext];
-            if (lang)
-                collected.add(lang);
-        }
-    }
-    catch (error) {
-        errors.push(`readdir ${root}: ${normalizeError(error)}`);
-    }
-    // `typescript` implies `javascript` runtime; keep both so the
-    // interview can ask "compiled-with vs run-with" if needed.
-    return Array.from(collected).sort();
-}
-/* ------------------------------------------------------------------ */
-/* Script picker                                                       */
-/* ------------------------------------------------------------------ */
-function pickScript(scripts, candidates) {
-    for (const key of candidates) {
-        const value = scripts[key];
-        if (typeof value === 'string' && value.trim().length > 0) {
-            // Surface the npm-style invocation so Phase 4 can quote it
-            // verbatim. The package manager name is filled in by the caller
-            // once it has resolved `packageManager`.
-            return key;
-        }
-    }
-    return undefined;
-}
-/* ------------------------------------------------------------------ */
-/* AI tool config scan                                                 */
-/* ------------------------------------------------------------------ */
-const AI_TOOL_CONFIG_PATHS = Object.freeze([
-    'CLAUDE.md',
-    'CLAUDE.local.md',
-    'AGENTS.md',
-    '.cursorrules',
-    '.cursor/rules',
-    '.github/copilot-instructions.md',
-    '.windsurfrules',
-    '.clinerules',
-    '.mcp.json',
-    'PUGI.md',
-    'PUGI.local.md',
-]);
-function scanAiToolConfigs(root) {
-    const result = {};
-    for (const rel of AI_TOOL_CONFIG_PATHS) {
-        result[rel] = existsSafe(join(root, rel));
-    }
-    return Object.freeze(result);
-}
-/* ------------------------------------------------------------------ */
-/* CI detection                                                        */
-/* ------------------------------------------------------------------ */
-const CI_PROBE_PATHS = Object.freeze([
-    '.github/workflows',
-    '.gitlab-ci.yml',
-    '.circleci/config.yml',
-    'azure-pipelines.yml',
-    '.travis.yml',
-    '.buildkite',
-]);
-function detectCi(root) {
-    return CI_PROBE_PATHS.some((rel) => existsSafe(join(root, rel)));
-}
-/* ------------------------------------------------------------------ */
-/* Safe IO helpers                                                     */
-/* ------------------------------------------------------------------ */
-function existsSafe(path) {
-    try {
-        return existsSync(path);
-    }
-    catch {
-        return false;
-    }
-}
-function safeReadJson(path, errors) {
-    try {
-        const stats = statSync(path);
-        if (!stats.isFile())
-            return undefined;
-        if (stats.size > MAX_READ_BYTES) {
-            errors.push(`oversize ${path}: ${stats.size} bytes`);
-            return undefined;
-        }
-        const raw = readFileSync(path, 'utf8');
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        errors.push(`read ${path}: ${normalizeError(error)}`);
-        return undefined;
-    }
-}
-function normalizeError(error) {
-    if (error instanceof Error)
-        return error.message;
-    return String(error);
-}
-//# sourceMappingURL=codebase-survey.js.map