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

package/dist/tui/vim-input.js

@@ -0,0 +1,267 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Leak L26 (2026-05-27) — Vim-mode-aware REPL input.
+ *
+ * Thin wrapper that sits BETWEEN the REPL session and the legacy
+ * `InputBox`. When vim mode is off it forwards every prop unchanged
+ * so existing operators see zero behavioural delta. When vim mode is
+ * on it intercepts keystrokes through `useInput` BEFORE Ink's normal
+ * dispatch and either:
+ *
+ *   - in `insert` mode, lets the keystroke fall through to `InputBox`
+ *     so the legacy buffer / cursor / history / palette code stays
+ *     authoritative (we do NOT re-implement insert-mode editing);
+ *   - in `normal` mode, routes the key through `core/vim/keymap.ts`
+ *     and applies the result to a shadow buffer + cursor mirror that
+ *     it then pushes back into `InputBox` via the existing `initial`
+ *     prop on remount.
+ *
+ * Why a wrapper instead of inlining into `InputBox`?
+ *
+ *   - Keeps the legacy input surface untouched for non-vim operators
+ *     (the L26 ship risks zero regression to ~year-old code).
+ *   - The wrapper renders a thin status row ABOVE the input frame so
+ *     the active mode + pending sequence + cheat sheet are visible.
+ *   - Tests can exercise the wrapper without dragging in the full
+ *     ink + clipboard stack of `InputBox` (the spec drives the
+ *     keymap directly; the wrapper is exercised via the runtime
+ *     command tests + manual smoke from the REPL).
+ *
+ * The component intentionally only models the SINGLE-LINE REPL prompt
+ * buffer — that is the surface Claude Code's `/vim` covers, and that
+ * is what the leak research validated. Multi-line + visual-mode +
+ * counts are out of scope for this sprint.
+ *
+ * ─── Closure-staleness contract (post-L26 fix, 2026-05-27) ───
+ *
+ * Three-of-three reviewers flagged the original `setShadowLine`
+ * functional updater for reading `shadowCursor` and `pending` from
+ * the closure, which goes stale across consecutive keystrokes
+ * (React batches dispatch, so the second `d` of `dd` saw the
+ * `pending` value from the render that scheduled the first `d`,
+ * not the post-first-d value). Same problem for cursor advancement
+ * across chained `l`/`h`/`w`/`b` presses.
+ *
+ * Additionally, calling `props.onSubmit` inline inside a setState
+ * updater is double-fired by React strict mode (updaters MUST be
+ * pure — strict mode runs them twice to surface impurity).
+ *
+ * The fix moves shadow cursor + pending + mode into `useRef`
+ * (refs survive across renders, are read synchronously, and are
+ * not subject to closure capture), drives the keymap dispatch
+ * OUTSIDE any setState callback, and defers `props.onSubmit` /
+ * `props.onExit` invocations until AFTER the render via the
+ * `useEffect` queued by toggling a transition ref.
+ *
+ * The `line` state is the only React state we mutate per keystroke
+ * because the inner `InputBox` re-reads it via the `initial` prop
+ * on remount — refs alone cannot trigger that remount. Cursor + mode
+ * + pending are surfaced to the render path through the same
+ * `line`/`tick` rerender, so the status bar stays in sync without
+ * itself being captured by a stale closure.
+ */
+import { useEffect, useRef, useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { handleNormalKey, PENDING_NONE, describePending, } from '../core/vim/keymap.js';
+import { InputBox } from './input-box.js';
+/**
+ * Render the mode badge + pending sequence + cheat sheet above the
+ * input frame. Two lines:
+ *
+ *   ─ NORMAL ─ d:                Esc=normal · i=insert · :w=submit · :q=cancel
+ *   ─ INSERT ─                   (mode-specific tail dropped when there's nothing to show)
+ *
+ * Plain ASCII + dim accents to match the rest of the REPL's chrome.
+ */
+function VimStatusBar(props) {
+    const modeLabel = props.mode === 'normal' ? '-- NORMAL --' : '-- INSERT --';
+    const pendingLabel = describePending(props.pending);
+    const hint = props.mode === 'normal'
+        ? 'h/j/k/l move  ·  i/a insert  ·  x del  ·  dd line  ·  :w submit  ·  :q cancel'
+        : 'Esc → normal mode';
+    return (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", bold: true, children: modeLabel }), pendingLabel.length > 0 ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsx(Text, { color: "yellow", children: `${pendingLabel}` })] })) : null, _jsx(Text, { children: " " }), _jsx(Text, { dimColor: true, children: hint })] }));
+}
+export function VimInput(props) {
+    const { vimEnabled, initialMode, ...inputBoxProps } = props;
+    // When vim mode is off we DO NOT mount the `useInput` overlay — the
+    // legacy `InputBox` keeps full ownership of the keystrokes and
+    // behaves byte-for-byte the way it always did. This is the same
+    // pattern `output-style` followed (off → pass through; on → activate
+    // the modal surface).
+    if (!vimEnabled) {
+        return _jsx(InputBox, { ...inputBoxProps });
+    }
+    // ─── Render-driving state ─────────────────────────────────────
+    //
+    // `line` + `tick` are the only pieces of state the render path
+    // reads — the inner `InputBox` is remounted on every `tick` bump
+    // so the `initial` prop is honoured. Cursor / pending / mode are
+    // held in refs (see below) and mirrored into render state via the
+    // same setLine/setTick burst at the end of each keystroke so the
+    // status bar stays in lockstep without ever being captured by a
+    // stale closure inside a setState updater.
+    const [line, setLine] = useState(props.initial ?? '');
+    const [mode, setMode] = useState(initialMode ?? 'normal');
+    const [pending, setPending] = useState(PENDING_NONE);
+    const [remountTick, setRemountTick] = useState(0);
+    // ─── Closure-safe scratch refs ────────────────────────────────
+    //
+    // These refs are written synchronously inside the `useInput`
+    // handler and read on the NEXT keystroke. They survive across
+    // renders, are not captured by stale closures, and are NEVER
+    // mutated inside a setState updater — so React strict-mode's
+    // double-invocation cannot corrupt them.
+    //
+    // Why not `useReducer`? A reducer would also see fresh state on
+    // every dispatch, but the keymap result is a tagged union whose
+    // side effects (mode flip, submit, cancel, remount) are easier
+    // to read as imperative steps after the pure `handleNormalKey`
+    // call. Refs keep the dispatcher linear and the diff vs the
+    // pre-fix file minimal.
+    const lineRef = useRef(props.initial ?? '');
+    const cursorRef = useRef(props.initial?.length ?? 0);
+    const pendingRef = useRef(PENDING_NONE);
+    const modeRef = useRef(initialMode ?? 'normal');
+    // Deferred side-effect queue — submit / exit must NOT run inline
+    // inside a setState updater (strict mode double-invokes them).
+    // We stash the payload here and flush it from a `useEffect` after
+    // the render commits.
+    const pendingSubmitRef = useRef(null);
+    const pendingExitRef = useRef(false);
+    const [sideEffectTick, setSideEffectTick] = useState(0);
+    useEffect(() => {
+        // Flush any deferred host callback exactly once per scheduled
+        // burst. The refs are nulled BEFORE the call so a re-entrant
+        // host onSubmit handler that re-renders us cannot re-fire the
+        // same payload.
+        const submit = pendingSubmitRef.current;
+        if (submit !== null) {
+            pendingSubmitRef.current = null;
+            props.onSubmit(submit);
+        }
+        if (pendingExitRef.current) {
+            pendingExitRef.current = false;
+            props.onExit();
+        }
+        // Intentionally only depends on `sideEffectTick`: we want this
+        // effect to fire ONLY when the keystroke handler asked for it
+        // (via setSideEffectTick), not on every prop change.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [sideEffectTick]);
+    useInput((input, key) => {
+        // Esc always returns to normal mode (and clears any pending
+        // sequence). This binding wins over `InputBox`'s own Esc handling
+        // because we own the `useInput` hook earlier in the render tree.
+        if (key.escape) {
+            modeRef.current = 'normal';
+            pendingRef.current = PENDING_NONE;
+            setMode('normal');
+            setPending(PENDING_NONE);
+            return;
+        }
+        // In insert mode we relinquish dispatch entirely so the legacy
+        // input box owns typing / palette / history / clipboard / kill
+        // ring without interference. Returning `undefined` from a
+        // `useInput` callback is a no-op — InputBox's own `useInput` will
+        // receive the same event on the next frame.
+        if (modeRef.current === 'insert')
+            return;
+        // In normal mode we drive the buffer through the keymap.
+        //
+        // CRITICAL: all inputs to `handleNormalKey` are read from refs,
+        // not from the React state closure captured at render time.
+        // This is what makes consecutive keystrokes ("ll", "dd", ":w")
+        // observe the post-previous-keystroke state instead of the
+        // pre-batch render snapshot.
+        const ch = input ?? '';
+        const curLine = lineRef.current;
+        const curCursor = cursorRef.current;
+        const curPending = pendingRef.current;
+        const out = handleNormalKey({
+            line: curLine,
+            cursor: curCursor,
+            pending: curPending,
+            ch,
+            enter: key.return,
+            escape: false,
+            backspace: key.backspace || key.delete,
+        });
+        // Step 1: write the new pending state to BOTH the ref (read by
+        // the next keystroke synchronously) AND the React state (drives
+        // the status bar render).
+        pendingRef.current = out.pending;
+        setPending(out.pending);
+        // Step 2: apply the discriminated result. Each branch updates
+        // the refs first (synchronous, closure-safe) and then schedules
+        // any required React state update or deferred side effect.
+        switch (out.result.kind) {
+            case 'move': {
+                cursorRef.current = out.result.cursor;
+                // Cursor lives in the ref; the inner InputBox does not need
+                // a remount for a pure motion, so we skip the tick bump.
+                break;
+            }
+            case 'edit': {
+                cursorRef.current = out.result.cursor;
+                lineRef.current = out.result.line;
+                setLine(out.result.line);
+                setRemountTick((t) => t + 1);
+                break;
+            }
+            case 'mode': {
+                cursorRef.current = out.result.cursor;
+                modeRef.current = out.result.mode;
+                setMode(out.result.mode);
+                break;
+            }
+            case 'submit': {
+                // Forward to the host's onSubmit and clear the shadow buffer
+                // so the next prompt starts empty. We DO NOT re-route
+                // through InputBox's Enter handler — that path also writes
+                // history; submitting from `:w` should mirror that, so we
+                // call props.onSubmit indirectly via the deferred-effect
+                // queue. (The host's history append happens inside InputBox;
+                // for the modal path the host can observe via props.onSubmit
+                // and append manually if needed. The leak-parity surface for
+                // L26 documents `:w` as equivalent to Enter so this is fine.)
+                const payload = out.result.payload;
+                if (payload.trim().length > 0) {
+                    // Queue the host callback; useEffect flushes it after the
+                    // render commits. This avoids React strict-mode's
+                    // double-invocation of setState updaters double-firing
+                    // onSubmit (which would, e.g., submit the same prompt
+                    // twice to the agent on every `:w`).
+                    pendingSubmitRef.current = payload;
+                }
+                cursorRef.current = 0;
+                lineRef.current = '';
+                setLine('');
+                setRemountTick((t) => t + 1);
+                setSideEffectTick((t) => t + 1);
+                break;
+            }
+            case 'cancel': {
+                cursorRef.current = 0;
+                lineRef.current = '';
+                setLine('');
+                setRemountTick((t) => t + 1);
+                break;
+            }
+            case 'noop': {
+                // No-op result still may have advanced `pending` (e.g. the
+                // first `d` of `dd` arms the pending state). The pending ref
+                // and state were already updated above, so nothing else to
+                // do here.
+                break;
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(VimStatusBar, { mode: mode, pending: pending }), _jsx(InputBox, { ...inputBoxProps, 
+                // In normal mode we seed the (possibly mutated) shadow line +
+                // suppress the blink so the operator's caret is unambiguously
+                // controlled by h/l/0/$/w/b. In insert mode we hand the
+                // buffer back to InputBox as-is so the legacy typing path
+                // takes over.
+                initial: mode === 'normal' ? line : (props.initial ?? line), blinkCursor: mode === 'normal' ? false : (props.blinkCursor ?? true) }, `vim-${remountTick}`)] }));
+}
+//# sourceMappingURL=vim-input.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-beta.21",
+  "version": "0.1.0-beta.23",
   "description": "Pugi CLI - terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
@@ -54,7 +54,7 @@
     "undici": "^8.3.0",
     "zod": "^3.23.0",
     "@pugi/personas": "0.1.2",
-    "@pugi/sdk": "0.1.0-beta.21"
+    "@pugi/sdk": "0.1.0-beta.23"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/dist/core/engine/compaction-hook.js

@@ -1,154 +0,0 @@
-/**
- * Engine loop integration point for the six-tier compaction engine.
- *
- * `maybeCompactAfterTool` is the single function the engine loop calls
- * after each tool result has been appended to the transcript. It:
- *
- *   1. Estimates current context-window pressure (transcript bytes
- *      against the model's budget, plus the static blocks).
- *   2. Calls `selectTier` on the snapshot.
- *   3. Runs the tier. Microcompact / cached_microcompact are sync;
- *      reactive_summary / session_memory / full_compaction / reset
- *      are async-shaped (the call returns before commit when run
- *      against a long transcript) but currently run inline — the
- *      engine loop is single-threaded today, so true backgrounding
- *      waits for the SSE consumer refactor in α5.7.
- *   4. Runs invariant checks against the result. On any violation,
- *      emits `compaction.invariant_violated` and returns the
- *      pre-compaction transcript untouched.
- *   5. On success, emits `compaction.completed` with reclaim numbers
- *      and returns the new transcript for the caller to adopt.
- *   6. On no-op, emits `compaction.skipped` and returns the original.
- *
- * Why a separate file (not inlined into `native-pugi.ts`):
- *
- *   Sprint α5.3 (feat/pugi-cli-hooks-lifecycle-m1-gap-c) is in flight
- *   and already modifies session.ts + tool-bridge + permission. Editing
- *   native-pugi.ts in this PR risks a merge conflict against α5.3's
- *   landing PR. Keeping the wiring as an exported helper means the
- *   one-line callsite in native-pugi.ts can be added in a tiny
- *   follow-up after both α5.3 and α5.5 have landed.
- *
- * Expected callsite in `apps/pugi-cli/src/core/engine/native-pugi.ts`,
- * inside `onToolResult`:
- *
- *   ```ts
- *   const compactionOutcome = await maybeCompactAfterTool({
- *     session,
- *     transcript: currentTranscript,
- *     toolOutputs: recentToolOutputs,
- *     contextBudgetUsed: estimatedTokens,
- *     contextBudgetMax: budget.maxTokens,
- *     workspaceRoot: root,
- *     contextStaticHash: {
- *       instructionsHash,
- *       toolSchemaHash,
- *     },
- *   });
- *   if (compactionOutcome.committed) {
- *     currentTranscript = compactionOutcome.newTranscript;
- *   }
- *   ```
- */
-import { runCompaction, selectTier, } from '../context/compaction.js';
-import { checkInvariants } from '../context/invariants.js';
-import { emitCompactionCompleted, emitCompactionInvariantViolated, emitCompactionSkipped, emitCompactionStarted, } from '../context/compaction-events.js';
-/**
- * Engine-loop callback. See file header for the expected callsite shape.
- *
- * Contract:
- *   - Never throws. All errors degrade to `committed: false` with the
- *     original transcript and an event record.
- *   - On `committed: true`, the caller MUST adopt `newTranscript` as
- *     the live working transcript for the next model turn.
- *   - On `committed: false`, the caller MUST keep the input transcript
- *     and try again on the next tool turn (compaction will retry once
- *     pressure stays above threshold).
- */
-export async function maybeCompactAfterTool(input) {
-    const compactionInput = {
-        sessionId: input.session.id,
-        contextBudgetUsed: input.contextBudgetUsed,
-        contextBudgetMax: input.contextBudgetMax,
-        toolOutputs: input.toolOutputs,
-        transcript: input.transcript,
-        workspaceRoot: input.workspaceRoot,
-    };
-    const tier = selectTier(compactionInput);
-    emitCompactionStarted(input.session, tier, {
-        budgetUsed: input.contextBudgetUsed,
-        budgetMax: input.contextBudgetMax,
-    });
-    let result;
-    try {
-        result = await runCompaction(compactionInput, tier);
-    }
-    catch (error) {
-        const reason = error instanceof Error ? error.message : String(error);
-        emitCompactionSkipped(input.session, tier, `compaction crashed: ${reason}`);
-        return {
-            committed: false,
-            tier,
-            newTranscript: input.transcript,
-            bytesReclaimed: 0,
-            newContextSize: byteSize(input.transcript),
-            violations: [],
-            skipped: true,
-            skipReason: `crashed: ${reason}`,
-        };
-    }
-    if (result.skipped) {
-        emitCompactionSkipped(input.session, tier, result.skipReason || 'no work');
-        return {
-            committed: false,
-            tier,
-            newTranscript: input.transcript,
-            bytesReclaimed: 0,
-            newContextSize: byteSize(input.transcript),
-            violations: [],
-            skipped: true,
-            skipReason: result.skipReason,
-        };
-    }
-    // Invariant gate: static-hash-unchanged is enforced by passing the
-    // same hashes in for `before` and `after` — compaction never touches
-    // static blocks, so the hashes are equal by construction. We pass
-    // both so the contract is explicit; if a future tier introduces a
-    // bug that overwrites static state, the check still catches it.
-    const violations = checkInvariants({
-        before: compactionInput,
-        after: result,
-        summaryText: result.summaryText,
-        staticHashBefore: input.contextStaticHash,
-        staticHashAfter: input.contextStaticHash,
-    });
-    if (violations.length > 0) {
-        for (const v of violations)
-            emitCompactionInvariantViolated(input.session, v);
-        return {
-            committed: false,
-            tier,
-            newTranscript: input.transcript,
-            bytesReclaimed: 0,
-            newContextSize: byteSize(input.transcript),
-            violations,
-            skipped: false,
-            skipReason: '',
-        };
-    }
-    emitCompactionCompleted(input.session, tier, result.bytesReclaimed, result.newContextSize, result.artifactsCreated);
-    return {
-        committed: true,
-        tier,
-        newTranscript: result.newTranscript,
-        bytesReclaimed: result.bytesReclaimed,
-        newContextSize: result.newContextSize,
-        violations: [],
-        skipped: false,
-        skipReason: '',
-    };
-}
-function byteSize(transcript) {
-    return transcript.reduce((sum, t) => sum + Buffer.byteLength(t.content, 'utf8'), 0);
-}
-//# sourceMappingURL=compaction-hook.js.map

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