@pugi/cli 0.1.0-beta.2 → 0.1.0-beta.20

package/dist/runtime/bootstrap.js

@@ -0,0 +1,190 @@
+/**
+ * Bootstrap helpers — β1b U7 / U8 (2026-05-26).
+ *
+ * Two related contracts:
+ *
+ *   - U7: when `pugi` runs in a bare directory (no `.pugi/` and no
+ *     project-marker file like `package.json` / `Cargo.toml` / `go.mod`)
+ *     AND we have a TTY, offer an interactive `pugi init`.
+ *
+ *   - U8: when `pugi` runs in a sub-directory of one or more parent
+ *     projects (each carrying a `.pugi/settings.json` OR a git root),
+ *     present a picker — "Found N projects: <list>. Pick OR /init here".
+ *
+ * Both checks are pure file-system queries; the interactive bridge
+ * lives one layer up (REPL bootstrap, slash-command palette). This
+ * module surfaces the structured result and the caller decides UX.
+ *
+ * Project markers we recognise (first match wins):
+ *   - `.pugi/settings.json` (highest priority — Pugi-aware project)
+ *   - `package.json` (Node / TypeScript / pnpm monorepo)
+ *   - `Cargo.toml`
+ *   - `go.mod`
+ *   - `pyproject.toml` / `requirements.txt` / `setup.py`
+ *   - `Gemfile`
+ *   - `composer.json`
+ *   - `pom.xml` / `build.gradle` / `build.gradle.kts`
+ *   - `.git/` directory (last resort — git repo root)
+ *
+ * Walk depth is capped at 12 ancestors. Anything deeper is operator
+ * error (running `pugi` from `/Users/x/Library/.../node_modules/...`)
+ * and a deeper walk would be slow + surprising.
+ *
+ * Brand voice: ASCII only.
+ */
+import { existsSync, statSync } from 'node:fs';
+import { dirname, resolve, basename } from 'node:path';
+const PROJECT_MARKER_FILES = [
+    '.pugi/settings.json',
+    'package.json',
+    'Cargo.toml',
+    'go.mod',
+    'pyproject.toml',
+    'requirements.txt',
+    'setup.py',
+    'Gemfile',
+    'composer.json',
+    'pom.xml',
+    'build.gradle',
+    'build.gradle.kts',
+];
+const MAX_PARENT_WALK = 12;
+/**
+ * Detect the workspace state at `cwd`. Pure file-system query; never
+ * throws. The caller pairs this with the TTY / --no-tty / --json flags
+ * to decide whether to prompt the operator.
+ */
+export function detectWorkspaceState(cwd) {
+    const absCwd = resolve(cwd);
+    // `.pugi/` at cwd always wins — we are already initialised.
+    if (hasPugiDir(absCwd)) {
+        return { kind: 'existing_pugi', root: absCwd };
+    }
+    // Project marker at cwd → proceed without prompting.
+    const cwdMarker = findMarkerAt(absCwd);
+    if (cwdMarker) {
+        return { kind: 'existing_project', root: absCwd, marker: cwdMarker };
+    }
+    // Walk parents — collect every ancestor that looks like a project.
+    const parents = findParentProjects(absCwd);
+    if (parents.length > 0) {
+        return { kind: 'inside_parent_projects', parents };
+    }
+    return { kind: 'bare' };
+}
+/**
+ * Walk parent directories up to MAX_PARENT_WALK ancestors, collecting
+ * every directory that has a project marker. Nearest-first. Stops at
+ * the filesystem root. Exported for U8 spec coverage + for callers
+ * that want the raw list (e.g. a /workspaces shell command).
+ */
+export function findParentProjects(cwd) {
+    const out = [];
+    let current = dirname(resolve(cwd));
+    let last = '';
+    let hops = 0;
+    while (current && current !== last && hops < MAX_PARENT_WALK) {
+        const marker = findMarkerAt(current);
+        if (marker) {
+            out.push({ root: current, marker });
+        }
+        last = current;
+        current = dirname(current);
+        hops += 1;
+    }
+    return out;
+}
+/**
+ * Return the first matching project marker filename inside `dir`, or
+ * null when none of the candidates exist. `.pugi/settings.json` is a
+ * file (not the directory), so we test both for symmetry — if the
+ * operator has `.pugi/` but no settings.json yet, we treat it as a
+ * Pugi-aware project (the directory itself is the signal).
+ */
+function findMarkerAt(dir) {
+    for (const marker of PROJECT_MARKER_FILES) {
+        const path = resolve(dir, marker);
+        try {
+            if (existsSync(path))
+                return marker;
+        }
+        catch {
+            /* permission error — treat as missing */
+        }
+    }
+    // `.git/` last — costly because it touches the FS but only when no
+    // other marker hit. Skip if `.git/` is a file (worktree shim) since
+    // we still want the worktree path.
+    const gitPath = resolve(dir, '.git');
+    try {
+        if (existsSync(gitPath))
+            return '.git';
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+/**
+ * True iff the directory has a `.pugi/` subdirectory. We check the
+ * directory itself (not the settings.json inside) because the moment
+ * `.pugi/` exists Pugi is "set up here" from the operator's POV —
+ * settings.json may be empty / lazily written.
+ */
+function hasPugiDir(dir) {
+    const path = resolve(dir, '.pugi');
+    try {
+        if (!existsSync(path))
+            return false;
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Build a human-friendly label for a project root: prefer the basename
+ * suffixed with the marker (`pugi (package.json)`). Used by the U8
+ * picker to render the list. Exported for spec coverage.
+ */
+export function projectLabel(root, marker) {
+    const name = basename(root) || root;
+    return `${name} (${marker})`;
+}
+/**
+ * Should we proactively offer `pugi init` in this invocation?
+ *
+ *   - kind === 'bare' → yes (U7)
+ *   - kind === 'inside_parent_projects' → yes (U8 picker, "or init here")
+ *   - existing_pugi / existing_project → no
+ *
+ * Caller must additionally gate on TTY + non-json mode. Exported so a
+ * UI layer can reuse the same decision rule without re-implementing
+ * the state switch.
+ */
+export function shouldOfferInit(state) {
+    return state.kind === 'bare' || state.kind === 'inside_parent_projects';
+}
+/**
+ * Convenience formatter: synthesize the prompt text U7 / U8 callers
+ * surface to the operator on the bare/inside-parents paths. The text
+ * is plain ASCII; the UI layer wraps it in Ink as needed.
+ */
+export function formatInitPrompt(state, cwd) {
+    switch (state.kind) {
+        case 'bare':
+            return `No project detected at ${cwd}. Run \`pugi init\` here?`;
+        case 'inside_parent_projects': {
+            const lines = state.parents.map((p) => `  - ${projectLabel(p.root, p.marker)} (${p.root})`);
+            return `Found ${state.parents.length} parent project(s):\n${lines.join('\n')}\nPick one above or run \`pugi init\` here.`;
+        }
+        default:
+            return '';
+    }
+}
+/* β1b r1: dropped the `_internal` re-export. It was a leftover from
+ * an earlier spec that asserted module load order; the test was
+ * removed but the export lingered. No callers consume it inside the
+ * monorepo (verified via repo-wide grep), and `verbatimModuleSyntax`
+ * is happy with the module's regular exports. */
+//# sourceMappingURL=bootstrap.js.map