super-backlog 0.3.1

package/dist/dashboard/layering.js

@@ -0,0 +1,94 @@
+// src/dashboard/layering.ts
+/**
+ * Layer tasks for the dependency graph: depth = 1 + max(depth of prerequisites).
+ *
+ * Deterministic by construction:
+ * - input node order drives every traversal and is preserved as Map key order;
+ * - edges referencing unknown nodes are ignored;
+ * - when no node is ready, the remaining cycle members are detected and appended,
+ *   as one group, to the deepest safe layer; their downstream dependents then
+ *   continue normally.
+ */
+export function assignLayers(nodes, deps) {
+    const nodeSet = new Set(nodes);
+    const prereqs = new Map();
+    for (const n of nodes)
+        prereqs.set(n, []);
+    for (const d of deps) {
+        if (!nodeSet.has(d.from) || !nodeSet.has(d.to))
+            continue; // dangling ref
+        const list = prereqs.get(d.from);
+        if (list && !list.includes(d.to))
+            list.push(d.to);
+    }
+    const layers = new Map();
+    const remaining = new Set(nodes);
+    let current = 0;
+    while (remaining.size > 0) {
+        const ready = nodes.filter((n) => remaining.has(n) && prereqs.get(n)?.every((p) => !remaining.has(p)));
+        if (ready.length === 0) {
+            // Stalled: every remaining node sits behind a cycle. Append exactly the
+            // self-reachable members to the next layer; the rest resume peeling.
+            const cyclic = cycleMembers(nodes, prereqs, remaining);
+            current += 1;
+            for (const n of nodes) {
+                if (cyclic.has(n)) {
+                    layers.set(n, current);
+                    remaining.delete(n);
+                }
+            }
+            if (cyclic.size === 0)
+                break; // unreachable safety net
+            continue;
+        }
+        current += 1;
+        for (const n of ready) {
+            layers.set(n, current);
+            remaining.delete(n);
+        }
+    }
+    if (remaining.size > 0) {
+        // Only reachable via the safety net; park leftovers on the deepest layer.
+        for (const n of nodes) {
+            if (remaining.has(n))
+                layers.set(n, Math.max(current, 1));
+        }
+    }
+    const out = new Map();
+    for (const n of nodes)
+        out.set(n, layers.get(n) ?? 1);
+    return out;
+}
+/** Nodes that can reach themselves using only edges inside `remaining`. */
+function cycleMembers(nodes, prereqs, remaining) {
+    const adj = new Map();
+    for (const n of nodes) {
+        if (!remaining.has(n))
+            continue;
+        adj.set(n, (prereqs.get(n) ?? []).filter((p) => remaining.has(p)));
+    }
+    const cyclic = new Set();
+    for (const start of nodes) {
+        if (!remaining.has(start) || cyclic.has(start))
+            continue;
+        const seen = new Set();
+        const stack = [...(adj.get(start) ?? [])];
+        let found = false;
+        while (stack.length > 0 && !found) {
+            const cur = stack.pop();
+            if (cur === undefined)
+                break;
+            if (cur === start) {
+                found = true;
+                break;
+            }
+            if (seen.has(cur))
+                continue;
+            seen.add(cur);
+            stack.push(...(adj.get(cur) ?? []));
+        }
+        if (found)
+            cyclic.add(start);
+    }
+    return cyclic;
+}

package/dist/dashboard/regen.js

@@ -0,0 +1,28 @@
+// src/dashboard/regen.ts
+// Standalone regeneration entry invoked by the post-commit freshness hook:
+//   node "<repo>/node_modules/super-backlog/dist/dashboard/regen.js"
+// Contract: never throw, never exit non-zero - a broken dashboard generation
+// must never block or fail a user's commit. All errors go to console.error.
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import process from 'node:process';
+import { collectDashboardData } from './data.js';
+import { renderDashboard } from './render.js';
+import { atomicWrite } from '../lib/atomic.js';
+import { KIT_VERSION } from '../lib/version.js';
+/** Regenerate <cwd>/dashboard.html. Throws on failure; the direct-run wrapper swallows. */
+export function regenerateDashboard(cwd) {
+    const html = renderDashboard(collectDashboardData(cwd, { kitVersion: KIT_VERSION }));
+    atomicWrite(join(cwd, 'dashboard.html'), html);
+}
+const invokedDirectly = process.argv[1] !== undefined &&
+    import.meta.url === pathToFileURL(resolve(process.argv[1])).href;
+if (invokedDirectly) {
+    try {
+        regenerateDashboard(process.cwd());
+    }
+    catch (err) {
+        console.error(err instanceof Error ? (err.stack ?? err.message) : err);
+    }
+    process.exit(0); // always - success or failure
+}

package/dist/dashboard/render.js

@@ -0,0 +1,75 @@
+// src/dashboard/render.ts
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/** The nine pipeline phases; must stay consistent with src/templates/workflow-block.md. */
+export const PIPELINE_PHASES = [
+    { n: 1, name: 'Idea', gate: 'User states a need; capture it before doing anything else' },
+    { n: 2, name: 'Brainstorming', gate: 'Explore intent, requirements and design before any creative work' },
+    { n: 3, name: 'Design gate', gate: 'Human approves the design document' },
+    { n: 4, name: 'Spec-to-backlog', gate: 'Decompose the approved design into reviewed tasks with acceptance criteria' },
+    { n: 5, name: 'Review gate', gate: 'Human reviews specs and acceptance criteria before any code exists' },
+    { n: 6, name: 'Plan-before-code', gate: 'A written implementation plan is approved by the human' },
+    { n: 7, name: 'TDD implementation', gate: 'Failing test first, then code; one task per session/PR' },
+    { n: 8, name: 'Verification & final summary', gate: 'Run tests/lint/typecheck; verification evidence before success claims' },
+    { n: 9, name: 'Merge & archive', gate: 'Merge the branch, then close/archive the task via the backlog CLI' },
+];
+function readTemplate() {
+    const here = dirname(fileURLToPath(import.meta.url)); // src/dashboard at dev time, dist/dashboard at runtime
+    const candidates = [
+        join(here, '..', 'templates', 'dashboard.html'),
+        join(here, 'templates', 'dashboard.html'),
+    ];
+    for (const c of candidates)
+        if (existsSync(c))
+            return readFileSync(c, 'utf8');
+    throw new Error('template not found: dashboard.html');
+}
+function esc(s) {
+    return s.replace(/[&<>"']/g, (c) => {
+        switch (c) {
+            case '&': return '&amp;';
+            case '<': return '&lt;';
+            case '>': return '&gt;';
+            case '"': return '&quot;';
+            default: return '&#39;';
+        }
+    });
+}
+function toneFor(status) {
+    const s = status.toLowerCase();
+    if (s === 'done' || s === 'complete' || s === 'completed')
+        return 'ok';
+    if (s.includes('progress') || s === 'review')
+        return 'accent';
+    if (s.includes('block') || s === 'rejected')
+        return 'danger';
+    if (s.includes('hold') || s.includes('wait') || s === 'draft')
+        return 'warn';
+    return 'dim';
+}
+/** Sidebar pills with live counts; click-to-filter wiring lands in a later task. */
+function statusPillsHtml(statuses) {
+    if (statuses.length === 0)
+        return '<span class="pill-empty">no data</span>';
+    return statuses
+        .map((s) => `<button type="button" class="pill" data-status="${esc(s.status)}"` +
+        ` data-count="${s.count}" data-tone="${toneFor(s.status)}">` +
+        `<span class="n">${s.count}</span> ${esc(s.status)}</button>`)
+        .join('\n      ');
+}
+function jsonIsland(value) {
+    return JSON.stringify(value).replace(/</g, '\\u003c');
+}
+/** Fill the static template shell with data; all dynamic task/metric content stays in the JSON islands. */
+export function renderDashboard(data) {
+    return readTemplate()
+        .replaceAll('__PROJECT_NAME__', () => esc(data.project.name))
+        .replaceAll('__PROJECT_DESC__', () => esc(data.project.description))
+        .replaceAll('__GENERATED_AT__', () => esc(data.generatedAt))
+        .replaceAll('__KIT_VERSION__', () => esc(data.kitVersion))
+        .replaceAll('__STATUS_PILLS__', () => statusPillsHtml(data.statuses))
+        .replaceAll('__SBL_DATA_JSON__', () => jsonIsland(data))
+        .replaceAll('__SBL_GLOSSARY_JSON__', () => jsonIsland(data.glossary))
+        .replaceAll('__SBL_PHASES_JSON__', () => jsonIsland(PIPELINE_PHASES));
+}

package/dist/dashboard/server.js

@@ -0,0 +1,109 @@
+// src/dashboard/server.ts
+import { spawn } from 'node:child_process';
+import { watch } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { isAbsolute, join } from 'node:path';
+import process from 'node:process';
+export const DASHBOARD_PORT = 6428;
+function openInBrowser(url) {
+    try {
+        if (process.platform === 'win32') {
+            spawn('cmd', ['/c', 'start', '', url], { detached: true, stdio: 'ignore' })
+                .on('error', () => { }) // async ENOENT must not become an uncaught throw
+                .unref();
+        }
+        else if (process.platform === 'darwin') {
+            spawn('open', [url], { detached: true, stdio: 'ignore' })
+                .on('error', () => { })
+                .unref();
+        }
+        else {
+            spawn('xdg-open', [url], { detached: true, stdio: 'ignore' })
+                .on('error', () => { })
+                .unref();
+        }
+    }
+    catch {
+        // best-effort only; a missing opener must never crash the server
+    }
+}
+/**
+ * Serve the latest dashboard bytes; changes inside <cwd>/backlog trigger
+ * `regenerate()` debounced by 300ms. Pass port 0 for an ephemeral port (tests).
+ */
+export async function startServeServer(cwd, opts = {}) {
+    const file = opts.file ?? 'dashboard.html';
+    const filePath = isAbsolute(file) ? file : join(cwd, file);
+    const regenerate = opts.regenerate;
+    let timer = null;
+    const debouncedRegenerate = () => {
+        if (!regenerate)
+            return;
+        if (timer !== null)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = null;
+            void Promise.resolve()
+                .then(regenerate)
+                .catch(() => { }); // regeneration failures never kill the server
+        }, 300);
+    };
+    let watcher = null;
+    try {
+        // recursive so subdirectory writes (e.g. backlog/tasks/*.md) fire on every platform
+        watcher = watch(join(cwd, 'backlog'), { persistent: true, recursive: true }, debouncedRegenerate);
+        watcher.on('error', () => { }); // e.g. watched dir removed mid-session
+    }
+    catch {
+        watcher = null; // no backlog dir -> no live reload; serving still works
+    }
+    const server = createServer((req, res) => {
+        const url = req.url ?? '/';
+        const method = req.method ?? 'GET';
+        if (method !== 'GET' || !(url === '/' || url === '/index.html')) {
+            res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+            res.end('not found');
+            return;
+        }
+        readFile(filePath)
+            .then((bytes) => {
+            res.writeHead(200, {
+                'content-type': 'text/html; charset=utf-8',
+                'cache-control': 'no-store',
+            });
+            res.end(bytes);
+        })
+            .catch(() => {
+            res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+            res.end('dashboard not generated yet');
+        });
+    });
+    const requestedPort = opts.port ?? DASHBOARD_PORT;
+    const port = await new Promise((resolvePort, rejectPort) => {
+        server.once('error', rejectPort);
+        server.listen(requestedPort, '127.0.0.1', () => {
+            const addr = server.address();
+            if (addr !== null && typeof addr === 'object')
+                resolvePort(addr.port);
+            else
+                resolvePort(requestedPort);
+        });
+    });
+    if (opts.openBrowser)
+        openInBrowser(`http://127.0.0.1:${port}/`);
+    return {
+        server,
+        port,
+        close() {
+            if (timer !== null)
+                clearTimeout(timer);
+            timer = null;
+            watcher?.close();
+            watcher = null;
+            return new Promise((resolveClose) => {
+                server.close(() => resolveClose());
+            });
+        },
+    };
+}

package/dist/init/execute.js

@@ -0,0 +1,232 @@
+// src/init/execute.ts
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import process from 'node:process';
+import { atomicWrite } from '../lib/atomic.js';
+import { installGuardHook, installRefreshHook } from '../lib/hooks.js';
+import { injectBlock } from '../lib/markers.js';
+import { applyPluginEntry } from '../lib/opencode.js';
+import { OwnershipError, renderSkill } from '../lib/ownership.js';
+import { addDevDependencies, mergeScripts, WANTED_DEVS, WANTED_SCRIPTS, } from '../lib/pkgjson.js';
+import { installCmdsFor } from '../lib/pm.js';
+import { resolveBacklogBin, runCapture } from '../lib/run.js';
+import { agentsBlockContents } from './planner.js';
+export class UpstreamError extends Error {
+}
+export class RefusalError extends Error {
+}
+const UPSTREAM_PKGS = ['backlog.md@latest', 'super-backlog@latest'];
+export const POINTER_HEADING_RE = /^##\s+Workflow system \(managed by super-backlog\)\s*$/m;
+export const CLAUDE_PLUGIN_INSTRUCTION = 'Claude Code: run /plugin install superpowers@claude-plugins-official inside Claude Code to enable the Superpowers plugin.';
+export const CLAUDE_PLUGIN_WARNING = 'claude plugin install must be run manually';
+export function findGitDir(startDir) {
+    let dir = resolve(startDir);
+    for (;;) {
+        const candidate = join(dir, '.git');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+function readTemplate(name) {
+    const here = dirname(fileURLToPath(import.meta.url)); // src/init at dev time, dist/init at runtime
+    const candidates = [join(here, '..', 'templates', name), join(here, 'templates', name)];
+    for (const c of candidates)
+        if (existsSync(c))
+            return readFileSync(c, 'utf8');
+    throw new Error(`template not found: ${name}`);
+}
+function readTextIfExists(path) {
+    return existsSync(path) ? readFileSync(path, 'utf8') : null;
+}
+function prettyJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function skipInstallEnv() {
+    const v = process.env.SBL_SKIP_INSTALL;
+    return v !== undefined && v !== '';
+}
+function fabricateBacklogConfig(cwd, projectName) {
+    atomicWrite(join(cwd, 'backlog', 'config.yml'), `project_name: ${projectName}\n`);
+}
+function runUpstreamInstall(cwd, op, ctx) {
+    if (op.pm === 'none')
+        throw new UpstreamError('cannot install dependencies without a package manager');
+    if (skipInstallEnv()) {
+        fabricateBacklogConfig(cwd, ctx.projectName);
+        return;
+    }
+    const { cmd, args } = installCmdsFor(op.pm, UPSTREAM_PKGS);
+    const inst = runCapture(cmd, args, cwd);
+    if (inst.status !== 0) {
+        throw new UpstreamError(`\`${cmd} ${args.join(' ')}\` failed with exit code ${inst.status}${inst.stderr.trim() ? `:\n${inst.stderr.trim()}` : ''}`);
+    }
+    if (ctx.hasBacklogConfig)
+        return;
+    const bin = resolveBacklogBin(cwd);
+    if (!bin)
+        throw new UpstreamError('backlog binary not found after dependency installation');
+    const init = runCapture(bin, ['init', ctx.projectName, '--defaults', '--agent-instructions', 'none'], cwd);
+    if (init.status !== 0) {
+        throw new UpstreamError(`\`${bin} init\` failed with exit code ${init.status}${init.stderr.trim() ? `:\n${init.stderr.trim()}` : ''}`);
+    }
+}
+export class InvalidJsonError extends Error {
+}
+/** Reads path and throws InvalidJsonError when present-but-unparseable. Missing/empty file passes. */
+export function validateJsonFile(path, label) {
+    const raw = readTextIfExists(path);
+    if (raw === null || raw.trim() === '')
+        return;
+    try {
+        JSON.parse(raw);
+    }
+    catch {
+        throw new InvalidJsonError(`${label} is not valid JSON - fix it manually, then re-run`);
+    }
+}
+function parseJsonFile(path, label) {
+    validateJsonFile(path, label);
+    return JSON.parse(readTextIfExists(path));
+}
+function applyMergeJson(cwd, op) {
+    if (op.path === 'package.json') {
+        const path = join(cwd, 'package.json');
+        const pkg = parseJsonFile(path, 'package.json');
+        const merged = addDevDependencies(mergeScripts(pkg, WANTED_SCRIPTS).pkg, WANTED_DEVS).pkg;
+        const next = prettyJson(merged);
+        if (readTextIfExists(path) === next)
+            return false;
+        atomicWrite(path, next);
+        return true;
+    }
+    const path = join(cwd, 'opencode.json');
+    let result;
+    try {
+        result = applyPluginEntry(parseJsonFile(path, 'opencode.json'));
+    }
+    catch (err) {
+        if (err instanceof OwnershipError)
+            throw new RefusalError(err.message);
+        throw err;
+    }
+    if (!result.changed)
+        return false;
+    atomicWrite(path, prettyJson(result.config));
+    return true;
+}
+function applyInjectAgentsBlock(cwd, ctx) {
+    const path = join(cwd, 'AGENTS.md');
+    const current = readTextIfExists(path) ?? '';
+    const injected = injectBlock(current, ctx.version, agentsBlockContents(ctx.version));
+    if (injected.action === 'unchanged')
+        return false;
+    atomicWrite(path, injected.content);
+    return true;
+}
+function applyClaudePointer(cwd) {
+    const path = join(cwd, 'CLAUDE.md');
+    const current = readTextIfExists(path) ?? '';
+    if (POINTER_HEADING_RE.test(current))
+        return false;
+    let template = readTemplate('claude-pointer.md');
+    if (!template.endsWith('\n'))
+        template += '\n';
+    const sep = current.length === 0 ? '' : current.endsWith('\n\n') ? '' : current.endsWith('\n') ? '\n' : '\n\n';
+    atomicWrite(path, current + sep + template);
+    return true;
+}
+const GLUE_SKILLS = ['spec-to-backlog', 'backlog-status-report', 'task-review-gate'];
+function applyCopySkills(cwd, version) {
+    for (const skill of GLUE_SKILLS) {
+        const rendered = renderSkill(readTemplate(`skill-${skill}.md`), version);
+        atomicWrite(join(cwd, '.opencode', 'skill', skill, 'SKILL.md'), rendered);
+        atomicWrite(join(cwd, '.claude', 'skills', skill, 'SKILL.md'), rendered);
+    }
+    return true;
+}
+async function applyGenerateDashboard(cwd, warnings) {
+    try {
+        // Non-literal specifier: the dashboard module lands in a later batch; a missing
+        // module must degrade to a warning here, never crash init.
+        const specifier = '../commands/dashboard.js';
+        const mod = (await import(specifier));
+        if (typeof mod.generateDashboard !== 'function') {
+            throw new Error('dashboard module does not export generateDashboard');
+        }
+        await mod.generateDashboard(cwd, { serve: false });
+    }
+    catch (err) {
+        warnings.push(`dashboard generation skipped (${err instanceof Error ? err.message : String(err)})`);
+    }
+    return true;
+}
+export async function executeActions(cwd, actions, ctx) {
+    const warnings = [];
+    let applied = 0;
+    let skipped = 0;
+    let claudeHarnessPlanned = false; // detected via the existing write-claude-pointer action path
+    for (const action of actions) {
+        switch (action.kind) {
+            case 'upstream-install':
+                runUpstreamInstall(cwd, action, ctx);
+                applied++;
+                break;
+            case 'merge-json':
+                applyMergeJson(cwd, action) ? applied++ : skipped++;
+                break;
+            case 'inject-agents-block':
+                applyInjectAgentsBlock(cwd, ctx) ? applied++ : skipped++;
+                break;
+            case 'write-claude-pointer':
+                applyClaudePointer(cwd) ? applied++ : skipped++;
+                claudeHarnessPlanned = true;
+                break;
+            case 'copy-skills':
+                applyCopySkills(cwd, ctx.version) ? applied++ : skipped++;
+                break;
+            case 'install-guard-hook': {
+                const gitDir = findGitDir(cwd);
+                if (!gitDir) {
+                    warnings.push('no .git directory found - guard hook not installed');
+                    skipped++;
+                }
+                else {
+                    installGuardHook(gitDir, ctx.version);
+                    applied++;
+                }
+                break;
+            }
+            case 'install-refresh-hook': {
+                const gitDir = findGitDir(cwd);
+                if (!gitDir) {
+                    warnings.push('no .git directory found - dashboard refresh hook not installed');
+                    skipped++;
+                }
+                else {
+                    installRefreshHook(gitDir, ctx.version);
+                    applied++;
+                }
+                break;
+            }
+            case 'generate-dashboard':
+                (await applyGenerateDashboard(cwd, warnings)) ? applied++ : skipped++;
+                break;
+            case 'write':
+                atomicWrite(join(cwd, action.path), action.contents);
+                applied++;
+                break;
+        }
+    }
+    // Spec §5.1: the marketplace plugin cannot be installed from a script - after
+    // writing skills, print the exact command and surface it as a warning (exit 4).
+    if (claudeHarnessPlanned) {
+        console.log(CLAUDE_PLUGIN_INSTRUCTION);
+        warnings.push(CLAUDE_PLUGIN_WARNING);
+    }
+    return { applied, skipped, warnings };
+}

package/dist/init/planner.js

@@ -0,0 +1,60 @@
+// src/init/planner.ts
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { applyPluginEntry } from '../lib/opencode.js';
+function readTemplate(name) {
+    const here = dirname(fileURLToPath(import.meta.url)); // src/init at dev time, dist/init at runtime
+    const candidates = [join(here, '..', 'templates', name), join(here, 'templates', name)];
+    for (const c of candidates)
+        if (existsSync(c))
+            return readFileSync(c, 'utf8');
+    throw new Error(`template not found: ${name}`);
+}
+export function agentsBlockContents(version) {
+    return readTemplate('workflow-block.md').replace(/\{\{VERSION\}\}/g, version);
+}
+export function planInit(state, opts, _version) {
+    const actions = [];
+    const warnings = [];
+    const degradedAuto = opts.pm === 'auto' && state.detectedPm === null;
+    if (!opts.skipInstall && !degradedAuto && opts.pm !== 'skip') {
+        if (opts.pm === 'auto' && state.detectedPm !== null) {
+            actions.push({ kind: 'upstream-install', pm: state.detectedPm });
+        }
+        else if (opts.pm !== 'auto') {
+            actions.push({ kind: 'upstream-install', pm: opts.pm });
+        }
+    }
+    if (degradedAuto && !opts.skipInstall) {
+        warnings.push('no package manager detected - dependency installation and package.json merge were skipped; ' +
+            'install backlog.md and super-backlog manually, or re-run with --pm <npm|pnpm|bun>');
+    }
+    // opencode.json merge depends only on harness selection and applyPluginEntry
+    // not throwing a near-miss - never on package.json presence or PM detection
+    if (opts.harnesses.includes('opencode')) {
+        try {
+            applyPluginEntry(state.opencodeConfig);
+            actions.push({ kind: 'merge-json', path: 'opencode.json', transform: 'plugin-entry' });
+        }
+        catch (err) {
+            warnings.push(err instanceof Error ? err.message : String(err));
+        }
+    }
+    if (!degradedAuto && state.pkgExists) {
+        actions.push({ kind: 'merge-json', path: 'package.json', transform: 'scripts-and-devdeps' });
+    }
+    if (opts.harnesses.length > 0) {
+        actions.push({ kind: 'inject-agents-block' });
+        actions.push({ kind: 'copy-skills' });
+    }
+    if (opts.harnesses.includes('claude'))
+        actions.push({ kind: 'write-claude-pointer' });
+    if (opts.guard)
+        actions.push({ kind: 'install-guard-hook' });
+    if (opts.refreshHook ?? true)
+        actions.push({ kind: 'install-refresh-hook' });
+    if (opts.dashboard)
+        actions.push({ kind: 'generate-dashboard' });
+    return { actions, warnings };
+}

package/dist/lib/atomic.js

@@ -0,0 +1,16 @@
+// src/lib/atomic.ts
+import { mkdirSync, renameSync, writeFileSync, rmSync } from 'node:fs';
+import { dirname } from 'node:path';
+export function atomicWrite(filePath, contents) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    const tmp = filePath + '.tmp';
+    writeFileSync(tmp, contents, 'utf8');
+    try {
+        renameSync(tmp, filePath);
+    }
+    catch (err) {
+        // Windows rename over an existing file can fail on some filesystems.
+        rmSync(filePath, { force: true });
+        renameSync(tmp, filePath);
+    }
+}