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

package/dist/core/vim/state.js

@@ -1,92 +0,0 @@
-/**
- * — Vim mode preference persistence.
- *
- * Single-tier storage (user-only, `~/.pugi/config.json`):
- *
- *  `{ ..., "vimMode": true }`
- *
- * The the upstream behavior the upstream tool persists `/vim` as a user-level
- * preference (not per-workspace) — vim-style editing is a body-memory
- * trait of the operator, not a per-repo concern. We match that.
- *
- * Reader tolerances mirror `core/output-style/state.ts`:
- *  - missing file       → returns `false` (vim mode off, the default)
- *  - empty file         → returns `false`
- *  - malformed JSON     → returns `false` (REPL must not crash on a
- *                           hand-edited config)
- *  - non-boolean        → returns `false`
- *
- * Writer is a read-modify-write — neighbouring keys (`outputStyle`,
- * `permissionMode`, …) survive a vim-mode flip.
- *
- * File mode 0o600 mirrors `core/output-style/state.ts` so the same
- * config does not silently downgrade its permission bits depending on
- * which helper last touched it.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, resolve } from 'node:path';
-/**
- * Env override for `~/.pugi`. Re-uses the same `PUGI_HOME` knob as
- * the output-style helpers so test sandboxes are uniform.
- */
-export const PUGI_HOME_ENV = 'PUGI_HOME';
-/** Default when the file is missing / malformed / does not set the key. */
-export const VIM_MODE_DEFAULT = false;
-/**
- * Read the persisted vim-mode preference. Pure read, never throws —
- * every IO failure path degrades to `VIM_MODE_DEFAULT`.
- */
-export function resolveVimMode(io = {}) {
-    const config = readConfigFile(userConfigPath(io.env ?? process.env));
-    return typeof config.vimMode === 'boolean' ? config.vimMode : VIM_MODE_DEFAULT;
-}
-/**
- * Write the vim-mode preference. Read-modify-write so neighbouring
- * config keys survive (`outputStyle`, `permissionMode`, …).
- */
-export function setVimMode(value, io = {}) {
-    const path = userConfigPath(io.env ?? process.env);
-    const config = readConfigFile(path);
-    config.vimMode = value;
-    writeConfigFile(path, config);
-}
-/**
- * Path resolver exported for the spec; production callers should use
- * `resolveVimMode` / `setVimMode`.
- */
-export function userConfigPath(env = process.env) {
-    const home = env[PUGI_HOME_ENV] ?? resolve(homedir(), '.pugi');
-    return resolve(home, 'config.json');
-}
-function readConfigFile(path) {
-    if (!existsSync(path))
-        return {};
-    let raw;
-    try {
-        raw = readFileSync(path, 'utf8');
-    }
-    catch {
-        return {};
-    }
-    if (raw.trim().length === 0)
-        return {};
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return {};
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
-        return {};
-    return parsed;
-}
-function writeConfigFile(path, config) {
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, {
-        encoding: 'utf8',
-        mode: 0o600,
-    });
-}
-//# sourceMappingURL=state.js.map

package/dist/core/watch-markers/marker-watcher.js

@@ -1,133 +0,0 @@
-/**
- * Watch-mode inline marker scanner — Aider AI?/AI! pattern.
- *
- * Watches a directory tree via chokidar (already в deps — used by
- * VS Code и most JS file-watchers). When a file changes, scans the
- * delta для inline markers и emits structured events. Pugi-flavoured
- * marker pair:
- *
- *  // PUGI?  → operator asks Pugi a question right here
- *  // PUGI!  → operator instructs Pugi to act right here
- *
- * Also accepts Aider-compatible `// AI?` / `// AI!` for muscle-memory
- * parity. Block comments and `# PUGI?` (Python / shell) are recognised
- * too — language is detected from extension, NOT parsed properly. The
- * goal is opportunistic ergonomics, not a precise parser.
- *
- * No tool dispatch happens here — this module emits events; downstream
- * code (engine integration follow-up) decides what to do.
- */
-import chokidar from 'chokidar';
-import { readFile } from 'node:fs/promises';
-import { EventEmitter } from 'node:events';
-import path from 'node:path';
-const DEFAULT_IGNORED = [
-    '**/node_modules/**',
-    '**/.git/**',
-    '**/dist/**',
-    '**/build/**',
-    '**/coverage/**',
-    '**/.next/**',
-    '**/.pugi/**',
-];
-const DEFAULT_MAX_FILE_BYTES = 256 * 1024;
-// Recognises `// PUGI?`, `# PUGI!`, `/* AI? ... */`, `<!-- PUGI! ... -->` and equivalents.
-// Capture group 1 = comment prefix, 2 = tag (PUGI | AI), 3 = symbol (? | !), 4 = trailing text.
-const MARKER_RE = /(?:\/\/|#|\/\*|<!--)\s*(PUGI|AI)([?!])\s*([^\n*-]*?)(?:\*\/|-->|$)/g;
-export class MarkerWatcher extends EventEmitter {
-    options;
-    watcher = null;
-    maxFileBytes;
-    constructor(options = {}) {
-        super();
-        this.options = options;
-        this.maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
-    }
-    /**
-     * Start watching `patterns`. Multiple calls without close() throw —
-     * one instance, one active watcher.
-     */
-    start(patterns) {
-        if (this.watcher) {
-            throw new Error('MarkerWatcher already started — call close() first');
-        }
-        const ignored = [...(this.options.ignored ?? DEFAULT_IGNORED)];
-        const opts = {
-            ignored,
-            ignoreInitial: this.options.ignoreInitial ?? true,
-            persistent: true,
-        };
-        if (this.options.cwd !== undefined) {
-            opts.cwd = this.options.cwd;
-        }
-        this.watcher = chokidar.watch(patterns, opts);
-        this.watcher.on('add', p => void this.scan(p));
-        this.watcher.on('change', p => void this.scan(p));
-        this.watcher.on('error', err => this.emit('error', err));
-    }
-    /** Stop watching и release file handles. Safe to call multiple times. */
-    async close() {
-        if (!this.watcher)
-            return;
-        await this.watcher.close();
-        this.watcher = null;
-    }
-    /**
-     * Scan a single file synchronously — bypasses the watcher entirely.
-     * Useful для one-shot scans / tests / initial-load passes.
-     */
-    async scanOnce(file) {
-        return this.collectFromFile(file);
-    }
-    async scan(file) {
-        const hits = await this.collectFromFile(file);
-        for (const hit of hits) {
-            this.emit('marker', hit);
-        }
-    }
-    async collectFromFile(file) {
-        let content;
-        // chokidar emits paths relative to its `cwd` option when set. Resolve
-        // so readFile doesn't fall back to the process CWD и miss the file.
-        const resolved = this.options.cwd && !path.isAbsolute(file)
-            ? path.join(this.options.cwd, file)
-            : file;
-        try {
-            const buf = await readFile(resolved);
-            if (buf.byteLength > this.maxFileBytes)
-                return [];
-            content = buf.toString('utf8');
-        }
-        catch (err) {
-            // File deleted between event and read, permissions, etc.
-            this.emit('error', err);
-            return [];
-        }
-        const hits = [];
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i += 1) {
-            const lineText = lines[i] ?? '';
-            MARKER_RE.lastIndex = 0;
-            let match;
-            while ((match = MARKER_RE.exec(lineText)) !== null) {
-                const tag = match[1] ?? 'PUGI';
-                const symbol = match[2] ?? '?';
-                const text = (match[3] ?? '').trim();
-                hits.push({
-                    file,
-                    line: i + 1,
-                    kind: symbol === '!' ? 'instruction' : 'question',
-                    tag,
-                    text,
-                });
-            }
-        }
-        return hits;
-    }
-}
-/** Standalone scan helper для callers that don't want a long-lived watcher. */
-export async function scanFileForMarkers(file, options = {}) {
-    const watcher = new MarkerWatcher({ maxFileBytes: options.maxFileBytes });
-    return watcher.scanOnce(file);
-}
-//# sourceMappingURL=marker-watcher.js.map

package/dist/core/worktree/include-parser.js

@@ -1,249 +0,0 @@
-/**
- * `.worktreeinclude` parser - PUGI-487.
- *
- * The `.worktreeinclude` file lives at the repository root and carries
- * gitignore-syntax patterns. Files that:
- *
- *   1. Match at least one pattern in `.worktreeinclude`, AND
- *   2. Are git-ignored (untracked-and-ignored OR explicitly ignored),
- *
- * get COPIED into a fresh `pugi --worktree <name>` tree right after
- * `git worktree add` finishes. Tracked files are NEVER copied because
- * git already brings them along on its own, and double-writing would
- * corrupt the worktree index.
- *
- * Why a separate include file instead of `.gitignore` negation
- * patterns?
- *
- *  - The common case is "I have an untracked `.env` with API keys that
- *    every parallel session needs". Listing it in `.gitignore` with
- *    a negation would force-add it to the repo, defeating the point.
- *  - Operators want a single-file, copy-pasteable manifest of WHAT
- *    leaves the main tree, not a derived view across `.gitignore`
- *    semantics.
- *
- * Pattern grammar (subset of gitignore):
- *
- *  - Lines starting with `#` are comments. Blank lines are skipped.
- *  - Trailing `/` means directory-only and applies recursively to
- *    every file under the directory.
- *  - Leading `!` is a negation pattern that REMOVES matches from
- *    prior includes. Multiple negations are processed in order.
- *  - `*` matches any character except `/`.
- *  - `**` matches any number of path segments.
- *  - `?` matches a single non-`/` character.
- *  - Patterns with NO `/` match anywhere in the tree (e.g. `.env`
- *    matches both `./.env` and `./apps/foo/.env`).
- *  - Patterns starting with `/` are anchored to the repository root.
- *
- * Brand voice: ASCII only, no emoji, no banned words.
- */
-import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync, statSync } from 'node:fs';
-import { resolve, sep, posix } from 'node:path';
-/** Default file name. */
-export const WORKTREE_INCLUDE_FILENAME = '.worktreeinclude';
-/**
- * Parse the textual contents of a `.worktreeinclude` file into a rule
- * list. Pure function - does not touch the filesystem. Exposed for
- * spec coverage and the cleanup/dry-run path.
- */
-export function parseWorktreeIncludeText(text, source = WORKTREE_INCLUDE_FILENAME) {
-    const rules = [];
-    const lines = text.split(/\r?\n/);
-    for (const raw of lines) {
-        const line = raw.trim();
-        if (line.length === 0)
-            continue;
-        if (line.startsWith('#'))
-            continue;
-        let body = line;
-        let negate = false;
-        if (body.startsWith('!')) {
-            negate = true;
-            body = body.slice(1);
-        }
-        if (body.length === 0)
-            continue;
-        let directoryOnly = false;
-        if (body.endsWith('/')) {
-            directoryOnly = true;
-            body = body.slice(0, -1);
-        }
-        let anchored = false;
-        if (body.startsWith('/')) {
-            anchored = true;
-            body = body.slice(1);
-        }
-        else if (body.includes('/')) {
-            // a non-leading slash also anchors per gitignore semantics
-            anchored = true;
-        }
-        if (body.length === 0)
-            continue;
-        rules.push({
-            raw: line,
-            pattern: body,
-            negate,
-            directoryOnly,
-            anchored,
-        });
-    }
-    return { rules, source };
-}
-/**
- * Load + parse `.worktreeinclude` from a repository root. Returns an
- * empty rule set when the file is absent or unreadable - a missing
- * include file is the normal case (no extras to copy).
- */
-export function loadWorktreeInclude(repoRoot) {
-    const path = resolve(repoRoot, WORKTREE_INCLUDE_FILENAME);
-    if (!existsSync(path)) {
-        return { rules: [], source: path };
-    }
-    try {
-        const text = readFileSync(path, 'utf8');
-        return parseWorktreeIncludeText(text, path);
-    }
-    catch {
-        return { rules: [], source: path };
-    }
-}
-const REGEX_ESCAPE = /[.+^${}()|[\]\\]/;
-/**
- * Convert a gitignore-style glob pattern into a regex source string.
- * Subset implementation: covers `*`, `**`, `?`, and escapes the rest.
- *
- * Uses index-based scanning so `**` is detected and consumed before a
- * single `*` substitution could eat the doubled form.
- */
-function globToRegexSource(pattern) {
-    let out = '';
-    for (let i = 0; i < pattern.length; i += 1) {
-        const ch = pattern.charAt(i);
-        if (ch === '*') {
-            if (pattern.charAt(i + 1) === '*') {
-                out += '.*';
-                i += 1;
-                continue;
-            }
-            out += '[^/]*';
-            continue;
-        }
-        if (ch === '?') {
-            out += '[^/]';
-            continue;
-        }
-        if (REGEX_ESCAPE.test(ch)) {
-            out += '\\' + ch;
-            continue;
-        }
-        out += ch;
-    }
-    return out;
-}
-/**
- * Decide whether `relPath` (a forward-slash, no-leading-slash path
- * relative to the repo root) is matched by the given rule list. The
- * last matching rule wins so a negation after an include drops the
- * entry and an include after a negation re-adds it.
- */
-export function matchesWorktreeInclude(relPath, rules, isDirectory = false) {
-    const normalized = relPath.replace(/\\+/g, '/');
-    let matched = false;
-    for (const rule of rules) {
-        if (rule.directoryOnly && !isDirectory) {
-            // directory-only rule still matches files UNDER the dir (handled
-            // below). Falls through to the file-match attempt.
-        }
-        const source = buildRegex(rule);
-        const re = new RegExp('^' + source + '$');
-        if (re.test(normalized)) {
-            matched = !rule.negate;
-            continue;
-        }
-        if (rule.directoryOnly) {
-            const reUnder = new RegExp('^' + source + '/.*$');
-            if (reUnder.test(normalized)) {
-                matched = !rule.negate;
-            }
-        }
-    }
-    return matched;
-}
-function buildRegex(rule) {
-    const body = globToRegexSource(rule.pattern);
-    if (rule.anchored) {
-        return body;
-    }
-    // Unanchored pattern matches anywhere in the tree. Allow a
-    // segment-aligned match by accepting either start-of-string or a
-    // `/` boundary before the pattern body.
-    return '(?:.*/)?' + body;
-}
-/**
- * Walk `repoRoot` and return every git-ignored file path that matches
- * the include rules. Tracked files are excluded because they ride
- * along with git automatically.
- *
- * Implementation note: rather than re-implement gitignore evaluation
- * the default lister shells out to
- * `git ls-files --others --ignored --exclude-standard` to get the
- * authoritative ignored-untracked list. Tracked files never appear in
- * that output, so the result is exactly the safe-to-copy candidate
- * pool.
- */
-export function collectWorktreeIncludeFiles(repoRoot, rules, options = {}) {
-    if (rules.length === 0)
-        return [];
-    const lister = options.listIgnored ?? defaultListIgnored;
-    const stat = options.isDirectory ?? defaultIsDirectory;
-    const candidates = lister(resolve(repoRoot));
-    const out = [];
-    for (const candidate of candidates) {
-        const rel = candidate.replace(/\\+/g, '/').replace(/^\.\//, '');
-        if (rel.length === 0)
-            continue;
-        if (rel.startsWith('.pugi/') || rel.startsWith('.claude/')) {
-            // Never copy Pugi or .claude state into the worktree. Those
-            // dirs are owned by the runtime and the include file should
-            // not be able to leak audit logs or stale session state.
-            continue;
-        }
-        const absPath = resolve(repoRoot, rel);
-        const isDir = stat(absPath);
-        if (matchesWorktreeInclude(rel, rules, isDir)) {
-            out.push(rel);
-        }
-    }
-    return out;
-}
-function defaultListIgnored(repoRoot) {
-    // `-z` emits NUL-separated paths, the only safe form when filenames
-    // may contain spaces or newlines.
-    const result = spawnSync('git', ['ls-files', '--others', '--ignored', '--exclude-standard', '-z'], {
-        cwd: repoRoot,
-        encoding: 'buffer',
-        shell: false,
-        maxBuffer: 64 * 1024 * 1024,
-    });
-    if (result.status !== 0 || !result.stdout)
-        return [];
-    const text = result.stdout.toString('utf8');
-    return text.split('\u0000').filter((s) => s.length > 0);
-}
-function defaultIsDirectory(absPath) {
-    try {
-        return statSync(absPath).isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/** Cross-platform path-join in posix form (for matching semantics). */
-export function joinRel(parent, child) {
-    return posix.join(parent.replace(/\\+/g, '/'), child);
-}
-/** Re-export the system separator so consumers do not have to import it. */
-export const PATH_SEP = sep;
-//# sourceMappingURL=include-parser.js.map

package/dist/core/worktree-manager/cleanup.js

@@ -1,123 +0,0 @@
-/**
- * Stale-worktree sweep — .
- *
- * Pairs with `WorktreeManager` to find worktrees whose agent has either:
- *
- *  1. No corresponding progress JSON under `.pugi/agent-progress/` (the
- *     writer never wrote one, OR the file was archived away), OR
- *  2. A progress JSON whose `status` is `completed` or `failed` (the
- *     agent finished — the worktree is no longer load-bearing).
- *
- * Crashed agents (status `running` with a stale lastUpdate) are NOT
- * swept; the leak-research contract says we LEAVE worktrees of crashed
- * agents in place for forensics. The operator can `pugi worktrees
- * cleanup <id>` manually after the post-mortem.
- *
- * Implementation notes:
- *
- *  - The cleanup is read-then-write: list the manager state, classify
- *    each entry, then call `manager.cleanup()` per stale id. Errors per
- *    entry never abort the loop — they accumulate in the report.
- *  - The progress directory we look at is the SAME `.pugi/agent-progress/`
- *    root the writer uses (resolved via the writer's env-aware helper).
- *  - `runStaleCleanup` is the only public entry point. The internal
- *    classifier is exported as `classifyStale` for spec coverage.
- *
- * Brand voice: ASCII only, no emoji, no banned words.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { resolveProgressDir } from '../agent-progress/writer.js';
-import { validateAgentProgress } from '../agent-progress/schema.js';
-import { WorktreeManager, } from './manager.js';
-/**
- * Classify a single worktree listing against the on-disk progress JSON.
- * Pure-ish — only reads from the progress file when one exists. Exposed
- * for the spec; production callers go through `runStaleCleanup`.
- */
-export function classifyStale(listing, progressDir, options = {}) {
-    const grace = options.crashedGraceMs ?? 30 * 60 * 1000;
-    const now = options.now ?? Date.now;
-    const progressPath = join(progressDir, `${listing.agentId}.json`);
-    if (!existsSync(progressPath)) {
-        return 'orphan_no_progress';
-    }
-    let raw;
-    try {
-        raw = readFileSync(progressPath, 'utf8');
-    }
-    catch {
-        // Unreadable progress file — treat as orphan so the operator can
-        // see it in the cleanup report. We never act on it silently.
-        return 'orphan_no_progress';
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return 'orphan_no_progress';
-    }
-    const validation = validateAgentProgress(parsed);
-    if (!validation.ok)
-        return 'orphan_no_progress';
-    const progress = validation.value;
-    if (progress.status === 'completed')
-        return 'stale_completed';
-    if (progress.status === 'failed')
-        return 'stale_failed';
-    // status === 'running' — check for crashed (stale lastUpdate)
-    const lastTs = Date.parse(progress.lastUpdate);
-    if (Number.isFinite(lastTs) && now() - lastTs > grace) {
-        return 'crashed_running';
-    }
-    return 'active';
-}
-/**
- * Run a single stale-worktree sweep. Removes only `stale_completed`,
- * `stale_failed`, and `orphan_no_progress` entries. Crashed-running
- * entries are LEFT IN PLACE per the L23 forensics contract, but they
- * appear in the report so the operator can act on them manually.
- */
-export function runStaleCleanup(managerOpts, options = {}) {
-    const manager = new WorktreeManager(managerOpts);
-    const report = {
-        scanned: 0,
-        classified: [],
-        removed: [],
-        preserved: [],
-        errors: [],
-    };
-    const listResult = manager.list();
-    if (!listResult.ok) {
-        report.errors.push({ agentId: '', detail: `list failed: ${listResult.detail}` });
-        return report;
-    }
-    const progressDir = options.progressDir ?? resolveProgressDir();
-    const listings = listResult.value;
-    report.scanned = listings.length;
-    for (const entry of listings) {
-        const cls = classifyStale(entry, progressDir, options);
-        report.classified.push({ agentId: entry.agentId, path: entry.path, class: cls });
-        if (cls === 'active' || cls === 'crashed_running') {
-            report.preserved.push({ agentId: entry.agentId, reason: cls });
-            continue;
-        }
-        if (options.dryRun) {
-            // Dry-run reports the classification only — no cleanup, no remove.
-            continue;
-        }
-        const cleanup = manager.cleanup(entry.agentId);
-        if (cleanup.ok) {
-            report.removed.push(entry.path);
-        }
-        else {
-            report.errors.push({
-                agentId: entry.agentId,
-                detail: `${cleanup.reason}: ${cleanup.detail}`,
-            });
-        }
-    }
-    return report;
-}
-//# sourceMappingURL=cleanup.js.map