@pugi/cli 0.1.0-beta.98 → 1.0.0-alpha.1

package/dist/core/repo-map/scanner.js

@@ -1,211 +0,0 @@
-/**
- * Repo-map scanner — .
- *
- * Walks the workspace via `fs.readdirSync` (sync, depth-first), filters
- * to a recognised set of source-language extensions, and applies the
- * shared `PugiIgnore` matcher so the same exclusion rules used by the
- * three-tier context skeleton also gate the repo-map.
- *
- * Why a stand-alone scanner (vs. reusing the skeleton walker):
- *
- *  1. The skeleton walker emits a flat `IndexArtifact[]` of every
- *     ignore-respecting file (markdown, configs, schemas, etc.) for
- *     the working-set heuristic. The repo-map ONLY needs source
- *     files — markdown headings and JSON keys are not "definitions"
- *     in the L28 sense. Filtering downstream is cheap, but the
- *     scanner gets to short-circuit on extension before stat'ing
- *     the file, which matters for monorepos with thousands of
- *     non-source artefacts (lockfiles, schemas, fixtures).
- *
- *  2. We need mtime + size per file so `cache.ts` can invalidate
- *     stale entries without re-parsing. The skeleton walker
- *     surfaces only paths.
- *
- *  3. The L28 contract caps the walk at `MAX_SRC_FILES` (5000) and
- *     individual files at `MAX_FILE_BYTES` (200 KiB). When the cap
- *     trips the scanner returns a `{ skipped: 'too-large' }`
- *     verdict rather than partial data — the consumer must decide
- *     whether to fall back to a no-op map or surface a hint к the
- *     operator. Surfacing partial data would silently bias the
- *     injected summary toward whichever subtree the walker happened
- *     to traverse first.
- *
- * The output is sorted (POSIX path string compare) so two runs over
- * the same workspace produce byte-identical `repo-map.json` caches —
- * `cache.ts` relies on stable ordering for its hash-free freshness
- * check. POSIX-style separators are used in `relPath` regardless of
- * platform so the cache file stays portable.
- *
- * Pure module surface: no logging, no network. Errors during readdir
- * on a single subtree (permission denied, symlink loop) are swallowed
- * and the walker continues — repo-map is a best-effort context
- * enrichment, never a gate.
- */
-import { readdirSync, statSync } from 'node:fs';
-import { join, posix, relative, resolve, sep } from 'node:path';
-/**
- * Hard ceiling on total source files surfaced by a single scan. The
- * engine context budget is the binding constraint — a 5K-file repo
- * already overflows the 2K-token injection cap so going higher buys
- * nothing but walker latency. Repos above the cap fall back к the
- * `{ skipped: 'too-large' }` verdict.
- */
-export const MAX_SRC_FILES = 5000;
-/**
- * Per-file size cap. Files larger than this are skipped — they are
- * almost always generated (compiled JS, vendored libs, encoded blobs)
- * and add noise without signal. The 200 KiB threshold mirrors the
- * skeleton walker's own `MAX_FILE_BYTES` so the two scans agree
- * on "what counts as a source file".
- */
-export const MAX_FILE_BYTES = 200 * 1024;
-/**
- * Source-language extensions the extractor knows how to parse. Adding
- * a language here without a matching extractor branch is a silent
- * no-op (the file shows up в the scan but extracts zero symbols);
- * the spec asserts the symmetry so a future PR cannot drift the two
- * lists out of sync.
- */
-export const SUPPORTED_EXTENSIONS = Object.freeze([
-    '.ts',
-    '.tsx',
-    '.js',
-    '.jsx',
-    '.mjs',
-    '.cjs',
-    '.md',
-    '.mdx',
-]);
-const defaultReaddir = (path) => readdirSync(path, { withFileTypes: true });
-const defaultStat = (path) => {
-    const s = statSync(path);
-    return { size: s.size, mtimeMs: s.mtimeMs };
-};
-/**
- * Walk the workspace once and return every source file the extractor
- * is willing to parse. The function is deliberately synchronous —
- * the underlying walks are CPU-bound, не I/O-bound, and the sync
- * call avoids the promise overhead that dominates for thousands of
- * small files. The L28 engine boot path runs this on a Node `setImmediate`
- * so the main thread is not blocked.
- */
-export function scanRepoForMap(options) {
-    const root = resolve(options.root);
-    const readdir = options.readdir ?? defaultReaddir;
-    const stat = options.stat ?? defaultStat;
-    const maxFiles = options.maxFiles ?? MAX_SRC_FILES;
-    const maxFileBytes = options.maxFileBytes ?? MAX_FILE_BYTES;
-    const ignore = options.ignore;
-    const files = [];
-    let walked = 0;
-    let skippedLarge = 0;
-    let skippedIgnored = 0;
-    let tooLarge = false;
-    /**
-     * Depth-first recursion. We push dirs into a manual stack instead of
-     * recursing in JS because deep monorepos (Nx with 100+ packages)
-     * have approached the v8 default stack limit on Windows runners
-     * before; an explicit stack is one less thing to debug.
-     */
-    const stack = [root];
-    while (stack.length > 0) {
-        const dir = stack.pop();
-        let entries;
-        try {
-            entries = readdir(dir);
-        }
-        catch {
-            // Permission denied / symlink loop / mid-flight delete — keep
-            // walking. Repo-map is best-effort context, never a gate.
-            continue;
-        }
-        for (const entry of entries) {
-            const abs = join(dir, entry.name);
-            const isDir = entry.isDirectory();
-            if (ignore.isIgnored(abs, isDir)) {
-                skippedIgnored += 1;
-                continue;
-            }
-            if (isDir) {
-                stack.push(abs);
-                continue;
-            }
-            if (!entry.isFile()) {
-                // Symlinks, sockets, FIFOs etc. Skip silently — they are not
-                // source code and stat'ing them can throw on broken links.
-                continue;
-            }
-            walked += 1;
-            const ext = extOf(entry.name);
-            if (!SUPPORTED_EXTENSIONS.includes(ext)) {
-                continue;
-            }
-            let statResult;
-            try {
-                statResult = stat(abs);
-            }
-            catch {
-                // File vanished between readdir and stat — skip.
-                continue;
-            }
-            if (statResult.size > maxFileBytes) {
-                skippedLarge += 1;
-                continue;
-            }
-            // Workspace-relative POSIX path. `relative` returns the host
-            // separator on Windows; normalise to forward slashes so the
-            // cache file is portable.
-            const rel = relative(root, abs).split(sep).join(posix.sep);
-            files.push({
-                relPath: rel,
-                absPath: abs,
-                ext,
-                sizeBytes: statResult.size,
-                mtimeMs: statResult.mtimeMs,
-            });
-            if (files.length > maxFiles) {
-                tooLarge = true;
-                break;
-            }
-        }
-        if (tooLarge)
-            break;
-    }
-    if (tooLarge) {
-        return {
-            ok: false,
-            root,
-            skipped: {
-                reason: 'too-large',
-                walked,
-            },
-        };
-    }
-    // Sort by POSIX path for stable cache output. Two runs over the
-    // same workspace yield byte-identical JSON so the cache hash check
-    // is a simple `mtime + size` per entry without a content digest.
-    files.sort((a, b) => (a.relPath < b.relPath ? -1 : a.relPath > b.relPath ? 1 : 0));
-    return {
-        ok: true,
-        root,
-        files,
-        stats: {
-            walked,
-            kept: files.length,
-            skippedLarge,
-            skippedIgnored,
-        },
-    };
-}
-/**
- * Lowercase extension including the leading dot, or '' when the
- * filename has no extension. Mirrors `node:path.extname` semantics —
- * inlined so the scanner has zero per-iteration call overhead.
- */
-function extOf(name) {
-    const dot = name.lastIndexOf('.');
-    if (dot < 0 || dot === 0)
-        return '';
-    return name.slice(dot).toLowerCase();
-}
-//# sourceMappingURL=scanner.js.map

package/dist/core/retro/git-collector.js

@@ -1,251 +0,0 @@
-/**
- * Git collector for `pugi retro`.
- *
- * Mines a window of git history into RawCommit[] using `git log
- * --numstat --no-renames` plus a few discrete `git` calls for branch
- * + base + user identity. All git invocations go through child_process
- * (execFile) so we never shell-expand operator-controlled values.
- *
- * The collector is intentionally tolerant of a "no git" workspace —
- * `pugi retro` should not crash on a fresh `pugi init` scratch dir.
- * `collectGitContext` returns an empty harvest with `hasGit: false`
- * so the renderer can emit a friendly empty-state.
- */
-import { execFile } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
-const GIT_LOG_FORMAT = '%H%x01%an%x01%ae%x01%aI%x01%at%x01%s%x01%b';
-const RECORD_SEP = '\x02';
-const FIELD_SEP = '\x01';
-/** Files counted as tests (used both for stats split + commit-type
- * classification when the author forgets a conventional prefix). */
-const TEST_FILE_RE = /(^|\/)(test|tests|spec|__tests__)\//i;
-const TEST_FILE_SUFFIX_RE = /\.(spec|test)\.(ts|tsx|js|jsx|mjs|cjs)$/i;
-function isTestFile(path) {
-    if (TEST_FILE_RE.test(path))
-        return true;
-    if (TEST_FILE_SUFFIX_RE.test(path))
-        return true;
-    return false;
-}
-/** Format a Date as `YYYY-MM-DDTHH:mm:ss` in LOCAL time (no `Z` suffix).
- * Spec: git log `--since` parses local-time strings when no Z is given.
- */
-export function formatLocalDateTime(d) {
-    const pad = (n) => n.toString().padStart(2, '0');
-    const y = d.getFullYear();
-    const mo = pad(d.getMonth() + 1);
-    const da = pad(d.getDate());
-    const h = pad(d.getHours());
-    const mi = pad(d.getMinutes());
-    const s = pad(d.getSeconds());
-    return `${y}-${mo}-${da}T${h}:${mi}:${s}`;
-}
-/** Detect whether the cwd lives inside a git working tree.
- * Cheap probe: checks for a `.git` dir/file, then falls back to the
- * actual `git rev-parse --is-inside-work-tree` for worktrees / submodules.
- */
-export async function isGitWorkspace(cwd) {
-    if (existsSync(join(cwd, '.git')))
-        return true;
-    try {
-        const { stdout } = await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd });
-        return stdout.trim() === 'true';
-    }
-    catch {
-        return false;
-    }
-}
-/** Resolve `origin/HEAD` symbolic ref → short name (e.g. `main`).
- * Falls back to `main` if the remote ref is not set (common in fresh
- * scratch repos with no remote).
- */
-export async function detectBaseBranch(cwd) {
-    try {
-        const { stdout } = await execFileAsync('git', ['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], { cwd });
-        const ref = stdout.trim();
-        if (!ref)
-            return 'main';
-        const idx = ref.lastIndexOf('/');
-        return idx === -1 ? ref : ref.slice(idx + 1);
-    }
-    catch {
-        return 'main';
-    }
-}
-export async function detectCurrentBranch(cwd) {
-    try {
-        const { stdout } = await execFileAsync('git', ['branch', '--show-current'], { cwd });
-        const branch = stdout.trim();
-        return branch || 'HEAD';
-    }
-    catch {
-        return 'HEAD';
-    }
-}
-export async function detectUserIdentity(cwd) {
-    const name = await readGitConfig(cwd, 'user.name');
-    const email = await readGitConfig(cwd, 'user.email');
-    return { name: name || 'You', email: email || '' };
-}
-async function readGitConfig(cwd, key) {
-    try {
-        const { stdout } = await execFileAsync('git', ['config', '--get', key], { cwd });
-        return stdout.trim();
-    }
-    catch {
-        return '';
-    }
-}
-/** Parse the multi-line `git log --numstat` output into RawCommit[].
- *
- * Format laid out as: `<header>\n<numstat lines>\n` per record,
- * records separated by RECORD_SEP. The header has 7 fields joined by
- * FIELD_SEP: sha, name, email, iso-date, epoch, subject, body. Each
- * numstat line is `<ins>\t<del>\t<path>`; binary diffs surface as
- * `-\t-\t<path>` and contribute 0/0 to the stats roll-up.
- */
-export function parseGitLog(raw) {
-    const records = raw.split(RECORD_SEP).map((r) => r.trim()).filter(Boolean);
-    const commits = [];
-    for (const record of records) {
-        const lines = record.split('\n');
-        const headerLine = lines[0];
-        if (!headerLine)
-            continue;
-        const headerFields = headerLine.split(FIELD_SEP);
-        if (headerFields.length < 7)
-            continue;
-        const sha = headerFields[0] ?? '';
-        const author = headerFields[1] ?? '';
-        const authorEmail = headerFields[2] ?? '';
-        const timestamp = headerFields[3] ?? '';
-        const epochRaw = headerFields[4] ?? '0';
-        const subject = headerFields[5] ?? '';
-        const body = headerFields[6] ?? '';
-        const epochSeconds = Number.parseInt(epochRaw, 10);
-        if (!sha || !Number.isFinite(epochSeconds))
-            continue;
-        const files = [];
-        let insertions = 0;
-        let deletions = 0;
-        let testInsertions = 0;
-        let testDeletions = 0;
-        for (let i = 1; i < lines.length; i += 1) {
-            const line = lines[i];
-            if (!line)
-                continue;
-            const parts = line.split('\t');
-            if (parts.length < 3)
-                continue;
-            const insRaw = parts[0] ?? '0';
-            const delRaw = parts[1] ?? '0';
-            const path = parts[2] ?? '';
-            if (!path)
-                continue;
-            const ins = insRaw === '-' ? 0 : Number.parseInt(insRaw, 10) || 0;
-            const del = delRaw === '-' ? 0 : Number.parseInt(delRaw, 10) || 0;
-            files.push(path);
-            insertions += ins;
-            deletions += del;
-            if (isTestFile(path)) {
-                testInsertions += ins;
-                testDeletions += del;
-            }
-        }
-        commits.push({
-            sha,
-            author,
-            authorEmail,
-            timestamp,
-            epochSeconds,
-            subject,
-            body,
-            files,
-            stats: { insertions, deletions, testInsertions, testDeletions },
-        });
-    }
-    return commits;
-}
-/** Run `git log` for the given window. The format string packs every
- * field we need into one stream so we only spawn git once. Records
- * are separated by RECORD_SEP and fields by FIELD_SEP (both control
- * characters that cannot appear inside commit text), so the parser
- * never confuses subject text containing tabs/newlines for delimiters.
- */
-async function runGitLog(cwd, window) {
-    const since = formatLocalDateTime(window.since);
-    const until = formatLocalDateTime(window.until);
-    const args = [
-        'log',
-        `--since=${since}`,
-        `--until=${until}`,
-        '--no-renames',
-        '--numstat',
-        `--pretty=format:${RECORD_SEP}${GIT_LOG_FORMAT}`,
-        'HEAD',
-    ];
-    try {
-        const { stdout } = await execFileAsync('git', args, {
-            cwd,
-            maxBuffer: 64 * 1024 * 1024,
-        });
-        return stdout;
-    }
-    catch {
-        return '';
-    }
-}
-/** Count commits between the merge-base of <base>...HEAD and HEAD —
- * i.e. how many commits the current branch has added over the base.
- * Returns 0 when the branch is base or the base ref is unknown.
- */
-export async function countCommitsAheadOfBase(cwd, base, since) {
-    try {
-        const { stdout } = await execFileAsync('git', [
-            'rev-list',
-            '--count',
-            `${base}..HEAD`,
-            `--since=${formatLocalDateTime(since)}`,
-        ], { cwd });
-        const n = Number.parseInt(stdout.trim(), 10);
-        return Number.isFinite(n) ? n : 0;
-    }
-    catch {
-        return 0;
-    }
-}
-export async function collectGitContext(options) {
-    const { cwd, window } = options;
-    const hasGit = await isGitWorkspace(cwd);
-    if (!hasGit) {
-        return {
-            hasGit: false,
-            cwd,
-            currentBranch: '',
-            baseBranch: '',
-            userName: '',
-            userEmail: '',
-            commits: [],
-        };
-    }
-    const [currentBranch, baseBranch, identity, rawLog] = await Promise.all([
-        detectCurrentBranch(cwd),
-        detectBaseBranch(cwd),
-        detectUserIdentity(cwd),
-        runGitLog(cwd, window),
-    ]);
-    const commits = parseGitLog(rawLog);
-    return {
-        hasGit: true,
-        cwd,
-        currentBranch,
-        baseBranch,
-        userName: identity.name,
-        userEmail: identity.email,
-        commits,
-    };
-}
-//# sourceMappingURL=git-collector.js.map

package/dist/core/retro/health-card.js

@@ -1,25 +0,0 @@
-/**
- * Workspace health card — Plane module oversize detection.
- *
- * Background (recall Pugi incident 2026-05-30): the Plane web UI
- * tripped a React error boundary when an admin-api module accumulated
- * ~200 issues. The actual REST API still returned 200, but the frontend
- * choked. The fix was to keep modules at or below 60 issues and split larger ones.
- *
- * The health card surfaces a P1 warning when a module exceeds the
- * recommended cap so the operator can split it before the next sprint.
- */
-/** Recommended max issues per Plane module. The retro card surfaces
- * any module exceeding this so the operator can split it. */
-export const OVERSIZED_MODULE_THRESHOLD = 60;
-export function computeHealthCard(modules) {
-    const oversized = modules
-        .filter((m) => m.issueCount > OVERSIZED_MODULE_THRESHOLD)
-        .sort((a, b) => b.issueCount - a.issueCount);
-    return {
-        totalModules: modules.length,
-        oversized,
-        oversizedThreshold: OVERSIZED_MODULE_THRESHOLD,
-    };
-}
-//# sourceMappingURL=health-card.js.map