@pugi/cli 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/core/init/scaffold.js

@@ -0,0 +1,195 @@
+/**
+ * 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