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

package/dist/core/init/scaffold.js

@@ -1,195 +0,0 @@
-/**
- * Workspace scaffold — extracted from `pugi init` so the bare REPL boot
- * can call it automatically when the operator launches `pugi` in a
- * fresh directory (CEO directive 2026-05-26).
- *
- * Before this module, `pugi init` was the only path that materialised
- * `.pugi/` + the canonical config files. Launching the REPL in an empty
- * directory printed `workspace: (not bound - run /init OR cd into
- * project)` and instructed the operator to Ctrl+C, run `pugi init`,
- * relaunch. That round trip is hostile on a first-touch install — CEO
- * escalated "auto = решение" on 2026-05-26.
- *
- * The module is intentionally side-effect free at import time: the
- * scaffold runs only when `ensureWorkspaceInitialized` is called. The
- * scaffold is also idempotent — every file write is gated by an
- * `existsSync` check, so re-running against a workspace that already has
- * `.pugi/settings.json` (e.g. a manual `pugi init` followed by auto-init
- * on next REPL launch) is a no-op. The function is safe to call before
- * any other init logic.
- *
- * Two CRITICAL invariants:
- *
- *   1. **Atomic per-file.** Every write uses `existsSync` + `writeFileSync`
- *      against the final path. There is no read-modify-write pattern that
- *      could lose data on a concurrent `pugi init` race. The one path
- *      that DOES mutate an existing file — `.gitignore` (append `.pugi/`
- *      marker) — also gates on the marker being absent before appending,
- *      so the worst-case race is a duplicate marker line that the next
- *      run skips.
- *
- *   2. **Silent by default.** When `opts.silent` is true (the REPL
- *      auto-init path) the scaffold writes NOTHING to stderr/stdout.
- *      The REPL bootstrap runs before Ink mounts, and a stray
- *      stdout/stderr write at that point would land on the operator's
- *      shell ABOVE the alt-screen entry — visible until they scroll up,
- *      and noisy in a CI tail. The explicit `pugi init` path stays
- *      verbose via the standalone command in `runtime/cli.ts`.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { emptyIndex } from '../index-store.js';
-/**
- * Materialise the canonical `.pugi/` workspace scaffold under `cwd`.
- * Returns a `{created, dir, createdPaths, skippedPaths}` summary so the
- * caller can log a one-shot "initialized" line on the first call without
- * re-checking the filesystem.
- *
- * The scaffold mirrors `pugi init` minus the bundled default-skills
- * install (that is a heavier operation gated on the `--no-defaults`
- * flag, and the standalone `pugi init` command keeps owning it).
- *
- * Idempotent: every file write gates on `existsSync`, so re-running
- * against an existing workspace is a no-op and returns
- * `{created: false}` with every path in `skippedPaths`.
- */
-export function ensureWorkspaceInitialized(cwd, opts = {}) {
-    const silent = opts.silent !== false;
-    const pugiDir = resolve(cwd, '.pugi');
-    // Local trackers so the existing helpers (mkdirIfMissing /
-    // writeJsonIfMissing / writeTextIfMissing) keep their (created, skipped)
-    // signature. The explicit `pugi init` command forwards these straight
-    // into its JSON payload.
-    const created = [];
-    const skipped = [];
-    mkdirIfMissing(pugiDir, created, skipped);
-    mkdirIfMissing(resolve(pugiDir, 'artifacts'), created, skipped);
-    mkdirIfMissing(resolve(pugiDir, 'sessions'), created, skipped);
-    mkdirIfMissing(resolve(pugiDir, 'skills'), created, skipped);
-    writeJsonIfMissing(resolve(pugiDir, 'settings.json'), {
-        schema: 1,
-        workflow: {
-            brand: 'pugi',
-            legacyName: 'codeforge',
-            approvals: 'auto',
-            notAutomatic: [],
-            defaultBaseBranch: 'dev',
-            branchPrefixes: ['feature', 'fix', 'refactor', 'chore'],
-            aiCoAuthorTrailers: false,
-        },
-        permissions: {
-            mode: 'auto',
-            allow: [],
-            deny: [],
-            notAutomatic: [],
-        },
-        privacy: {
-            mode: 'balanced',
-            telemetry: 'off',
-        },
-        artifacts: {
-            defaultPath: '.pugi/artifacts',
-            promoteExplicitly: true,
-        },
-    }, created, skipped);
-    writeJsonIfMissing(resolve(pugiDir, 'mcp.json'), { schema: 1, servers: [] }, created, skipped);
-    writeJsonIfMissing(resolve(pugiDir, 'index.json'), emptyIndex(), created, skipped);
-    writeTextIfMissing(resolve(pugiDir, 'PUGI.md'), [
-        '# Pugi Project Context',
-        '',
-        '## Product Workflow',
-        '',
-        '- Public product name: Pugi',
-        '- Default flow: idea -> build -> review',
-        '- Approvals are automatic by default until a repo, environment, workflow, or action is marked notAutomatic.',
-        '- Do not add AI Co-Authored-By trailers.',
-        '- Generated code, comments, commits, PR text, and technical docs default to English.',
-        '',
-        '## Project Notes',
-        '',
-        '- Add repo-specific architecture, commands, and business rules here.',
-        '- Do not store secrets, real IPs, private key paths, tokens, or credentials here.',
-        '',
-    ].join('\n'), created, skipped);
-    writeTextIfMissing(resolve(cwd, '.pugiignore'), [
-        '# Pugi ignore rules',
-        '.env',
-        '.env.*',
-        '!.env.example',
-        'node_modules/',
-        'dist/',
-        '.next/',
-        'coverage/',
-        '*.log',
-        '*.pem',
-        '*.key',
-        '*.crt',
-        '*.p12',
-        '*.sql',
-        '*.dump',
-        '',
-    ].join('\n'), created, skipped);
-    ensurePugiGitIgnore(cwd, created, skipped);
-    // `silent` is honoured implicitly — this module never writes to
-    // stdout/stderr. The flag exists so the standalone `pugi init` command
-    // can layer its own logger on top (it does, in runtime/cli.ts), while
-    // the auto-init REPL path leaves the boot stream untouched. We
-    // reference the flag here to defeat the lint "unused" warning and to
-    // document the contract in the source.
-    void silent;
-    return {
-        created: created.length > 0,
-        dir: pugiDir,
-        createdPaths: created,
-        skippedPaths: skipped,
-    };
-}
-/* ------------------------------------------------------------------ */
-/* Helpers (mirror the previous in-file implementations in cli.ts)     */
-/* ------------------------------------------------------------------ */
-function mkdirIfMissing(path, created, skipped) {
-    if (existsSync(path)) {
-        skipped.push(path);
-        return;
-    }
-    mkdirSync(path, { recursive: true });
-    created.push(path);
-}
-function writeJsonIfMissing(path, value, created, skipped) {
-    writeTextIfMissing(path, `${JSON.stringify(value, null, 2)}\n`, created, skipped);
-}
-function writeTextIfMissing(path, value, created, skipped) {
-    if (existsSync(path)) {
-        skipped.push(path);
-        return;
-    }
-    writeFileSync(path, value, { encoding: 'utf8', mode: 0o600 });
-    created.push(path);
-}
-/**
- * Ensure the workspace `.gitignore` ignores `.pugi/`. The function is
- * additive: it leaves an existing `.gitignore` body intact and appends
- * the marker only when none of `.pugi/`, `/.pugi/`, or `.pugi` is
- * already present. On a fresh repo with no `.gitignore` it creates the
- * file with the single marker line. Mode 0o600 matches the rest of the
- * scaffold so a paranoid CI does not surface "world-readable" warnings.
- */
-function ensurePugiGitIgnore(cwd, created, skipped) {
-    const gitignorePath = resolve(cwd, '.gitignore');
-    const marker = '.pugi/';
-    if (!existsSync(gitignorePath)) {
-        writeFileSync(gitignorePath, `${marker}\n`, { encoding: 'utf8', mode: 0o600 });
-        created.push(gitignorePath);
-        return;
-    }
-    const current = readFileSync(gitignorePath, 'utf8');
-    const lines = current.split('\n').map((line) => line.trim());
-    if (lines.includes(marker) || lines.includes('/.pugi/') || lines.includes('.pugi')) {
-        skipped.push(gitignorePath);
-        return;
-    }
-    const next = current.endsWith('\n') ? `${current}${marker}\n` : `${current}\n${marker}\n`;
-    writeFileSync(gitignorePath, next, { encoding: 'utf8' });
-    created.push(`${gitignorePath} (+${marker})`);
-}
-//# sourceMappingURL=scaffold.js.map

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