@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.2

package/dist/core/citations/parser.js

@@ -1,109 +0,0 @@
-import { promises as fs } from 'node:fs';
-import * as path from 'node:path';
-const EXT_GROUP = 'ts|tsx|js|jsx|md|json|sh|py|yaml|yml';
-const BRACKET_RE = new RegExp(String.raw `\[([^\]\s]+\.(?:` + EXT_GROUP + String.raw `)):(\d+)(?:-(\d+))?\]`, 'g');
-const PAREN_RE = new RegExp(String.raw `\(([^()\s]+\.(?:` + EXT_GROUP + String.raw `)):(\d+)(?:-(\d+))?\)`, 'g');
-function collect(text, re, out) {
-    re.lastIndex = 0;
-    let match;
-    while ((match = re.exec(text)) !== null) {
-        const raw = match[0];
-        const filePath = match[1];
-        const lineStr = match[2];
-        const endStr = match[3];
-        if (filePath === undefined || lineStr === undefined)
-            continue;
-        const line = Number.parseInt(lineStr, 10);
-        if (!Number.isFinite(line))
-            continue;
-        const citation = {
-            raw,
-            path: filePath,
-            line,
-            startOffset: match.index,
-            endOffset: match.index + raw.length,
-        };
-        if (endStr !== undefined) {
-            const endLine = Number.parseInt(endStr, 10);
-            if (Number.isFinite(endLine))
-                citation.endLine = endLine;
-        }
-        out.push(citation);
-    }
-}
-export function parseCitations(text) {
-    const out = [];
-    collect(text, BRACKET_RE, out);
-    collect(text, PAREN_RE, out);
-    out.sort((a, b) => a.startOffset - b.startOffset);
-    return out;
-}
-function isTraversal(rawPath) {
-    if (path.isAbsolute(rawPath))
-        return true;
-    const segments = rawPath.split(/[/\\]+/);
-    return segments.includes('..');
-}
-function countLines(content) {
-    if (content.length === 0)
-        return 0;
-    const matches = content.match(/\n/g);
-    const nl = matches === null ? 0 : matches.length;
-    return content.endsWith('\n') ? nl : nl + 1;
-}
-export async function validateCitations(citations, workspaceRoot) {
-    const rootReal = await fs.realpath(workspaceRoot);
-    const results = [];
-    for (const citation of citations) {
-        if (isTraversal(citation.path)) {
-            results.push({ citation, valid: false, reason: 'path-traversal' });
-            continue;
-        }
-        const resolved = path.resolve(rootReal, citation.path);
-        let realResolved;
-        try {
-            realResolved = await fs.realpath(resolved);
-        }
-        catch {
-            results.push({ citation, valid: false, reason: 'file-missing' });
-            continue;
-        }
-        const rel = path.relative(rootReal, realResolved);
-        if (rel.startsWith('..') || path.isAbsolute(rel)) {
-            results.push({ citation, valid: false, reason: 'outside-workspace' });
-            continue;
-        }
-        let stat;
-        try {
-            stat = await fs.stat(realResolved);
-        }
-        catch {
-            results.push({ citation, valid: false, reason: 'file-missing' });
-            continue;
-        }
-        if (!stat.isFile()) {
-            results.push({ citation, valid: false, reason: 'file-missing' });
-            continue;
-        }
-        let content;
-        try {
-            content = await fs.readFile(realResolved, 'utf8');
-        }
-        catch {
-            results.push({ citation, valid: false, reason: 'file-missing' });
-            continue;
-        }
-        const totalLines = countLines(content);
-        const lastLine = citation.endLine ?? citation.line;
-        const rangeInvalid = citation.line < 1 ||
-            lastLine < citation.line ||
-            lastLine > totalLines;
-        if (rangeInvalid) {
-            results.push({ citation, valid: false, reason: 'line-out-of-range' });
-            continue;
-        }
-        results.push({ citation, valid: true });
-    }
-    return results;
-}
-//# sourceMappingURL=parser.js.map

package/dist/core/classifier/yolo-classifier.js

@@ -1,88 +0,0 @@
-export const DEFAULT_RULES = [
-    { name: 'rm-recursive-force', pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*f|-[a-zA-Z]*f[a-zA-Z]*r|-rf|-fr)\b/, kind: 'destructive', baseConfidence: 0.95 },
-    { name: 'sudo-prefix', pattern: /^\s*sudo\b/, kind: 'destructive', baseConfidence: 0.85 },
-    { name: 'git-force-push', pattern: /\bgit\s+push\b.*--force\b|\bgit\s+push\b.*\s-f\b/, kind: 'destructive', baseConfidence: 0.92 },
-    { name: 'drop-table', pattern: /\bDROP\s+(TABLE|DATABASE|SCHEMA)\b/i, kind: 'destructive', baseConfidence: 0.95 },
-    { name: 'mkfs', pattern: /\bmkfs(\.\w+)?\b/, kind: 'destructive', baseConfidence: 0.95 },
-    { name: 'dd-of-device', pattern: /\bdd\b.*\bof=\/dev\//, kind: 'destructive', baseConfidence: 0.95 },
-    { name: 'chmod-recursive-permissive', pattern: /\bchmod\s+-R\s+777\b/, kind: 'risky', baseConfidence: 0.8 },
-    { name: 'curl-pipe-shell', pattern: /\bcurl\b[^|]*\|\s*(sudo\s+)?(ba)?sh\b/, kind: 'risky', baseConfidence: 0.85 },
-    { name: 'ls-listing', pattern: /^\s*ls(\s|$)/, kind: 'safe', baseConfidence: 0.9 },
-    { name: 'cd-navigate', pattern: /^\s*cd(\s|$)/, kind: 'safe', baseConfidence: 0.9 },
-    { name: 'cat-read', pattern: /^\s*cat\s+/, kind: 'safe', baseConfidence: 0.88 },
-    { name: 'echo-print', pattern: /^\s*echo\s+/, kind: 'safe', baseConfidence: 0.9 },
-    { name: 'pwd-print', pattern: /^\s*pwd\s*$/, kind: 'safe', baseConfidence: 0.95 },
-    { name: 'git-status', pattern: /^\s*git\s+(status|log|diff|branch|show)\b/, kind: 'safe', baseConfidence: 0.9 },
-];
-const DEFAULT_AMBIGUITY_THRESHOLD = 0.7;
-function parseLlmResponse(raw) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (!parsed || typeof parsed !== 'object')
-        return null;
-    const kind = parsed.kind;
-    const confidence = parsed.confidence;
-    if (kind !== 'safe' && kind !== 'risky' && kind !== 'destructive' && kind !== 'unknown') {
-        return null;
-    }
-    if (typeof confidence !== 'number' || !Number.isFinite(confidence)) {
-        return null;
-    }
-    const clamped = Math.max(0, Math.min(1, confidence));
-    return { kind, confidence: clamped };
-}
-function matchRules(input, rules) {
-    for (const rule of rules) {
-        if (rule.pattern.test(input)) {
-            return { rule };
-        }
-    }
-    return null;
-}
-export async function classifyInput(input, options = {}) {
-    const rules = options.rules ?? DEFAULT_RULES;
-    const threshold = options.ambiguityThreshold ?? DEFAULT_AMBIGUITY_THRESHOLD;
-    const transport = options.transport;
-    const match = matchRules(input, rules);
-    if (match && match.rule.baseConfidence >= threshold) {
-        return {
-            kind: match.rule.kind,
-            confidence: match.rule.baseConfidence,
-            stage: 'regex',
-            matchedRule: match.rule.name,
-        };
-    }
-    if (!transport) {
-        if (match) {
-            return {
-                kind: match.rule.kind,
-                confidence: match.rule.baseConfidence,
-                stage: 'regex',
-                matchedRule: match.rule.name,
-            };
-        }
-        return { kind: 'unknown', confidence: 0, stage: 'fallback' };
-    }
-    let raw;
-    try {
-        raw = await transport(input);
-    }
-    catch {
-        return { kind: 'unknown', confidence: 0, stage: 'fallback' };
-    }
-    const parsed = parseLlmResponse(raw);
-    if (!parsed) {
-        return { kind: 'unknown', confidence: 0, stage: 'fallback' };
-    }
-    return {
-        kind: parsed.kind,
-        confidence: parsed.confidence,
-        stage: 'llm',
-    };
-}
-//# sourceMappingURL=yolo-classifier.js.map

package/dist/core/clipboard.js

@@ -1,70 +0,0 @@
-import { spawn } from 'node:child_process';
-/**
- * Write `text` to the platform clipboard. Best-effort, async.
- */
-export async function writeClipboard(text, deps = {}) {
-    const platform = deps.platform ?? process.platform;
-    const spawnWrite = deps.spawnWrite ?? defaultSpawnWrite;
-    if (platform === 'darwin') {
-        const ok = await spawnWrite('pbcopy', [], text);
-        return { copied: ok };
-    }
-    if (platform === 'win32') {
-        // clip.exe is shipped with every Windows >= XP. UTF-16LE would be
-        // ideal, but a UTF-8 BOM-less write covers the ASCII subset that
-        // device-flow URLs use (no non-ASCII characters reach this path).
-        const ok = await spawnWrite('clip', [], text);
-        return { copied: ok };
-    }
-    if (platform === 'linux' || platform === 'freebsd' || platform === 'openbsd') {
-        // Wayland-native sessions usually have wl-copy and not xclip. Try
-        // wl-copy first if WAYLAND_DISPLAY is set, otherwise prefer xclip.
-        const order = process.env.WAYLAND_DISPLAY
-            ? ['wl-copy', 'xclip', 'xsel']
-            : ['xclip', 'wl-copy', 'xsel'];
-        for (const tool of order) {
-            const args = tool === 'xclip' ? ['-selection', 'clipboard'] : tool === 'xsel' ? ['--clipboard', '--input'] : [];
-            const ok = await spawnWrite(tool, args, text);
-            if (ok)
-                return { copied: true };
-        }
-        return { copied: false };
-    }
-    return { copied: false };
-}
-/**
- * Real spawn. Writes `text` to the child's stdin and resolves with
- * `true` only when the child exits 0. Errors (missing binary,
- * permission denied, non-zero exit) flip the result to `false`.
- */
-function defaultSpawnWrite(cmd, args, text) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const settle = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(value);
-        };
-        try {
-            const options = {
-                stdio: ['pipe', 'ignore', 'ignore'],
-                shell: false,
-            };
-            const child = spawn(cmd, args.slice(), options);
-            child.on('error', () => settle(false));
-            child.on('close', (code) => settle(code === 0));
-            const stdin = child.stdin;
-            if (!stdin) {
-                settle(false);
-                return;
-            }
-            stdin.on('error', () => settle(false));
-            stdin.end(text, 'utf8');
-        }
-        catch {
-            settle(false);
-        }
-    });
-}
-//# sourceMappingURL=clipboard.js.map

package/dist/core/codegraph/decision-store.js

@@ -1,248 +0,0 @@
-/**
- * Codegraph install-decision store — .
- *
- * Persists the operator's verdict on the codegraph install prompt so we
- * never spam them after a single decline. The 30-day reminder cadence
- * lets us re-surface the offer on big-enough repos in case the operator
- * said "not now" the first time and then forgot codegraph exists.
- *
- * Schema (workspace-scoped at `.pugi/codegraph-decision.json`):
- *
- *  {
- *    "schema": 1,
- *    "offeredAt": "2026-05-27T00:00:00.000Z",
- *    "accepted": false,
- *    "decliningCount": 1,
- *    "remindAfter": "2026-06-26T00:00:00.000Z", // 30 days from offeredAt
- *    "lastIndexedAt": null,                       // ISO date string OR null
- *    "lastReindexCheckAt": null
- *  }
- *
- * The store is workspace-local (each repo gets its own decision) so
- * declining codegraph in repo A does not suppress the prompt in repo B.
- * `.pugi/` already exists by the time we land here (pugi init scaffolds
- * it), so the directory creation is best-effort defence-in-depth.
- *
- * Concurrency: every write is `tmp + rename` so a partial write cannot
- * surface a corrupt JSON. Reads tolerate missing files + corrupt JSON
- * by returning `null` — the caller decides whether to fall back to
- * "offer again" (safe default) or "do nothing" (cold-start path).
- *
- * Pure persistence. No telemetry, no logging. The emitter lives in the
- * call sites so the decision store stays unit-testable in isolation.
- */
-import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
-import { resolve } from 'node:path';
-/**
- * Reminder cadence — 30 days from the last decline. Operators who said
- * no in a small repo that grew к medium during a sprint deserve a
- * follow-up; operators who said no last week do not. The window is
- * exposed as a const so the spec can pin it.
- */
-export const REMIND_AFTER_DAYS = 30;
-/**
- * Stale-index threshold for the cold-start "refresh me" reminder.
- * Seven days is the cadence the upstream codegraph docs recommend for
- * monorepos that ship multiple times a day; lower repos can wait
- * longer. The spec pins it.
- */
-export const STALE_INDEX_DAYS = 7;
-/**
- * Resolve the decision file path for a workspace root. Pure — exposed
- * для spec parity.
- */
-export function decisionPath(workspaceRoot) {
-    return resolve(workspaceRoot, '.pugi/codegraph-decision.json');
-}
-/**
- * Read the persisted decision. Returns null on missing file, malformed
- * JSON, or wrong schema version. The caller MUST treat null as "no
- * decision yet" — not "operator declined".
- */
-export function readDecision(workspaceRoot) {
-    const path = decisionPath(workspaceRoot);
-    if (!existsSync(path))
-        return null;
-    let raw;
-    try {
-        raw = readFileSync(path, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-    if (!isDecisionShape(parsed))
-        return null;
-    return parsed;
-}
-/**
- * Type guard. Defensive — a future schema bump should land a migration
- * here. For now: schema MUST be 1; required string fields MUST be
- * strings; optional fields may be null OR string.
- */
-function isDecisionShape(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const v = value;
-    if (v.schema !== 1)
-        return false;
-    if (typeof v.offeredAt !== 'string')
-        return false;
-    if (typeof v.accepted !== 'boolean')
-        return false;
-    if (typeof v.decliningCount !== 'number' || !Number.isFinite(v.decliningCount))
-        return false;
-    if (typeof v.remindAfter !== 'string')
-        return false;
-    if (v.lastIndexedAt !== null && typeof v.lastIndexedAt !== 'string')
-        return false;
-    if (v.lastReindexCheckAt !== null && typeof v.lastReindexCheckAt !== 'string')
-        return false;
-    return true;
-}
-/**
- * Atomic write. Creates `.pugi/` if it does not exist (pugi init owns
- * that surface ordinarily; we defend the rare cold-start path).
- */
-export function writeDecision(workspaceRoot, decision) {
-    const path = decisionPath(workspaceRoot);
-    const dir = resolve(workspaceRoot, '.pugi');
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
-    const tmp = `${path}.tmp.${process.pid}`;
-    writeFileSync(tmp, `${JSON.stringify(decision, null, 2)}\n`, { mode: 0o600 });
-    try {
-        renameSync(tmp, path);
-    }
-    catch (error) {
-        // Rename can fail if the destination was concurrently swapped on
-        // some platforms (Windows). Fall back to unlink + rename so the
-        // best-effort write does not throw to the caller.
-        try {
-            unlinkSync(path);
-        }
-        catch {
-            // ignore
-        }
-        renameSync(tmp, path);
-        void error;
-    }
-}
-/**
- * Decide whether to surface the install prompt on init. Returns the
- * full decision shape for callers that want to inspect the cadence;
- * a `true` verdict means "yes, ask the operator now".
- */
-export function shouldOfferOnInit(workspaceRoot, nowIso = new Date().toISOString()) {
-    const prior = readDecision(workspaceRoot);
-    if (!prior) {
-        return { shouldOffer: true, reason: 'first-run' };
-    }
-    if (prior.accepted) {
-        return { shouldOffer: false, reason: 'accepted-already' };
-    }
-    if (Date.parse(nowIso) >= Date.parse(prior.remindAfter)) {
-        return { shouldOffer: true, reason: 'reminder-due' };
-    }
-    return { shouldOffer: false, reason: 'recent-decline' };
-}
-/**
- * Record the operator's decision atomically. Mirrors the structure on
- * disk — callers do NOT hand-craft the schema.
- */
-export function recordDecision(workspaceRoot, input) {
-    const nowIso = input.nowIso ?? new Date().toISOString();
-    const prior = readDecision(workspaceRoot);
-    const decliningCount = input.accepted ? 0 : (prior?.decliningCount ?? 0) + 1;
-    const remindAfter = new Date(Date.parse(nowIso) + REMIND_AFTER_DAYS * 24 * 60 * 60 * 1000).toISOString();
-    const decision = {
-        schema: 1,
-        offeredAt: nowIso,
-        accepted: input.accepted,
-        decliningCount,
-        remindAfter,
-        lastIndexedAt: prior?.lastIndexedAt ?? null,
-        lastReindexCheckAt: prior?.lastReindexCheckAt ?? null,
-    };
-    writeDecision(workspaceRoot, decision);
-    return decision;
-}
-/**
- * Stamp the last-indexed timestamp. Called by /codegraph-status when
- * the operator triggers a reindex from inside Pugi. Updates the
- * `accepted` decision in place — never flips the install state.
- */
-export function markIndexed(workspaceRoot, nowIso = new Date().toISOString()) {
-    const prior = readDecision(workspaceRoot);
-    if (!prior)
-        return null;
-    const next = {
-        ...prior,
-        lastIndexedAt: nowIso,
-        lastReindexCheckAt: nowIso,
-    };
-    writeDecision(workspaceRoot, next);
-    return next;
-}
-/**
- * Stamp the last reindex-check timestamp without changing the index
- * itself. Used by the cold-start hook so we do not show the "index is
- * stale" hint on every keystroke once the operator has acknowledged
- * it.
- */
-export function markReindexChecked(workspaceRoot, nowIso = new Date().toISOString()) {
-    const prior = readDecision(workspaceRoot);
-    if (!prior)
-        return null;
-    const next = {
-        ...prior,
-        lastReindexCheckAt: nowIso,
-    };
-    writeDecision(workspaceRoot, next);
-    return next;
-}
-/**
- * Compute the staleness of the codegraph index. Pure — no IO.
- *
- *  - returns null when `lastIndexedAt` is null (never indexed)
- *  - returns the day-delta (rounded down) otherwise
- */
-export function indexAgeDays(decision, nowIso = new Date().toISOString()) {
-    if (!decision.lastIndexedAt)
-        return null;
-    const deltaMs = Date.parse(nowIso) - Date.parse(decision.lastIndexedAt);
-    if (!Number.isFinite(deltaMs) || deltaMs < 0)
-        return 0;
-    return Math.floor(deltaMs / (24 * 60 * 60 * 1000));
-}
-/**
- * Convenience predicate — should the cold-start hook show the stale-
- * index reminder? `true` when the index is older than STALE_INDEX_DAYS
- * AND we did NOT already remind the operator today.
- */
-export function shouldNudgeStaleIndex(decision, nowIso = new Date().toISOString()) {
-    if (!decision.accepted)
-        return false;
-    const age = indexAgeDays(decision, nowIso);
-    if (age === null)
-        return false;
-    if (age < STALE_INDEX_DAYS)
-        return false;
-    // Throttle the nudge to once per day so the operator does not see it
-    // on every REPL keystroke.
-    if (decision.lastReindexCheckAt) {
-        const lastCheckDelta = Date.parse(nowIso) - Date.parse(decision.lastReindexCheckAt);
-        if (Number.isFinite(lastCheckDelta) && lastCheckDelta < 24 * 60 * 60 * 1000) {
-            return false;
-        }
-    }
-    return true;
-}
-//# sourceMappingURL=decision-store.js.map