@clearlydev/nx-archweave 0.0.0-stage → 0.1.1

package/dist/generators/init/render.js

@@ -0,0 +1,125 @@
+import { packageManagerCommands } from '@nx-archweave/template-engine';
+import { renderAddFsdLiteReport } from "../add-fsd-lite/render.js";
+import { renderAddAgentRulesReport } from "../add-agent-rules/render.js";
+import { renderAddGithubTemplatesReport } from "../add-github-templates/render.js";
+import { renderAddReviewReport } from "../add-review/render.js";
+import { renderAddBackendBody } from "../add-backend/render.js";
+const SECTION_TITLES = {
+    fsd: 'add-fsd-lite',
+    agentRules: 'add-agent-rules',
+    githubTemplates: 'add-github-templates',
+    review: 'add-review',
+    backend: 'add-backend',
+};
+function renderSectionReport(report) {
+    switch (report.kind) {
+        case 'fsd':
+            return renderAddFsdLiteReport(report.report);
+        case 'agentRules':
+            return renderAddAgentRulesReport(report.report);
+        case 'githubTemplates':
+            return renderAddGithubTemplatesReport(report.report);
+        case 'review':
+            return renderAddReviewReport(report.report);
+        case 'backend':
+            return renderAddBackendBody(report.report);
+    }
+}
+/** Whether a section left the run in a state that only a `git restore .` can cleanly
+ * undo — i.e. it aborted outright. Sections that merely proposed/skipped a file (no
+ * write happened) do not count: there is nothing of theirs to roll back. */
+function sectionAborted(section) {
+    if (section.thrownError !== undefined)
+        return true;
+    if (section.report === null)
+        return false;
+    if (section.report.kind === 'fsd')
+        return section.report.report.aborted;
+    if (section.report.kind === 'review')
+        return section.report.report.workflowAction === 'aborted';
+    return false;
+}
+export function renderInitReport(report) {
+    const lines = [];
+    const backendSuffix = report.backend === 'none' ? '' : `, backend: ${report.backend}`;
+    const header = `init (preset: ${report.preset}, frontend: ${report.frontend}${backendSuffix})`;
+    lines.push(report.dryRun ? `${header} — dry run` : header);
+    if (report.refused) {
+        lines.push('');
+        lines.push('Refused: the working tree has uncommitted changes.');
+        lines.push('  init only runs against a clean working tree, so a partial run can always be undone');
+        lines.push('  with a single `git restore .` — commit or stash your changes, then rerun.');
+        return lines.join('\n');
+    }
+    for (const section of report.sections) {
+        // backend 'none' must leave the output byte-identical to the frontend-only
+        // era (silence guarantee) — a disabled backend section is omitted
+        // entirely, not shown as skipped.
+        if (section.id === 'backend' && !section.enabled)
+            continue;
+        lines.push('');
+        lines.push(`## ${SECTION_TITLES[section.id]}`);
+        if (!section.enabled) {
+            lines.push(section.id === 'fsd' && report.frontend === 'none'
+                ? '  skipped (backend-only workspace — no frontend to structure)'
+                : '  skipped (disabled for this run)');
+            continue;
+        }
+        if (section.thrownError !== undefined) {
+            lines.push(`  aborted — unexpected error: ${section.thrownError}`);
+            lines.push('  Nothing was written for this section. Rerun add-fsd-lite directly once resolved.');
+            continue;
+        }
+        if (section.report !== null) {
+            lines.push(renderSectionReport(section.report));
+        }
+    }
+    if (report.config !== undefined && (report.config.action !== 'skipped' || report.config.notRecorded.length > 0)) {
+        lines.push('');
+        lines.push('## toolkit.config.json');
+        const fieldList = report.config.fields.join(', ');
+        switch (report.config.action) {
+            case 'created':
+            case 'updated':
+                lines.push(`  ${report.dryRun ? 'would record' : 'recorded'} ${fieldList} (${report.config.action})`);
+                break;
+            case 'unchanged':
+                lines.push(`  already records ${fieldList} (unchanged)`);
+                break;
+            case 'unrecognized':
+                lines.push(`  not updated — the file is not a JSON object, so init left it alone (it never rewrites a shape it`);
+                lines.push(`  does not recognize). Add ${fieldList} by hand so standalone reruns resolve the same values.`);
+                break;
+            case 'skipped':
+                break;
+        }
+        if (report.config.notRecorded.length > 0) {
+            lines.push(`  not recorded: ${report.config.notRecorded.map((n) => n.field).join(', ')} — that section did not apply cleanly`);
+            lines.push('  this run (aborted, or written as an alternate file). Once resolved, record it with:');
+            const runNx = packageManagerCommands(report.packageManager ?? 'pnpm').runNx;
+            for (const entry of report.config.notRecorded)
+                lines.push(`    ${runNx} g @clearlydev/nx-archweave:${entry.rerun}`);
+        }
+    }
+    const ranDirty = report.allowDirty === true && !report.cleanTree && !report.dryRun;
+    if (ranDirty) {
+        lines.push('');
+        lines.push('Note: --allowDirty was set and the working tree already had uncommitted changes —');
+        lines.push('`git restore .` also reverts those pre-existing changes, not only what this run wrote.');
+    }
+    const hadAbort = report.sections.some(sectionAborted);
+    if (!report.dryRun && hadAbort) {
+        lines.push('');
+        if (ranDirty) {
+            lines.push('One or more sections aborted. Everything this run wrote can be undone with:');
+            lines.push('  git restore .');
+            lines.push('  (--allowDirty: this also reverts the pre-existing uncommitted changes noted above.)');
+        }
+        else {
+            lines.push('One or more sections aborted. init never runs against a dirty tree (see above), so everything');
+            lines.push('this run wrote can be undone in one step:');
+            lines.push('  git restore .');
+        }
+    }
+    return lines.join('\n');
+}

package/dist/generators/init/validation.js

@@ -0,0 +1,74 @@
+import { spawnSync } from 'node:child_process';
+import { spawnableCommand } from '@nx-archweave/shared';
+export function createProcessExec() {
+    return (command, args, options) => {
+        // nx / actionlint may be .cmd shims on Windows, which Node cannot start without cmd.exe.
+        const spawnable = spawnableCommand(command, args);
+        const result = spawnSync(spawnable.command, spawnable.args, {
+            cwd: options?.cwd,
+            encoding: 'utf-8',
+            windowsVerbatimArguments: spawnable.windowsVerbatimArguments,
+        });
+        return { status: result.status ?? null, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+    };
+}
+/** Runs `exec`, catching anything it throws (e.g. a stub or an unforeseen environment
+ * failure) so a single check can never take down the rest of validation — the "never
+ * throws" half of the best-effort contract applies even to the injected dependency, not
+ * just to non-zero exit codes. */
+function safeExec(exec, command, args, options) {
+    try {
+        return exec(command, args, options);
+    }
+    catch (error) {
+        return { status: null, stdout: '', stderr: error instanceof Error ? error.message : String(error) };
+    }
+}
+/** Post-flush, best-effort validation: never throws, only
+ * reports via console. Runs after the generator's `GeneratorCallback` fires, once every
+ * file this run wrote is actually on disk. Neither actionlint nor nx are added as
+ * dependencies — both are invoked as external binaries, detected at call time. */
+export function runPostInitValidation(input, exec) {
+    console.log('');
+    console.log('Post-run validation (best-effort):');
+    if (input.workflowPaths.length === 0) {
+        console.log('  actionlint: skipped (no GitHub Actions workflow files were written this run)');
+    }
+    else {
+        const versionCheck = safeExec(exec, 'actionlint', ['--version'], { cwd: input.root });
+        if (versionCheck.status !== 0) {
+            console.log('  actionlint: not found on PATH — skipped.');
+            console.log('    Install it from https://github.com/rhysd/actionlint to validate workflow files locally.');
+        }
+        else {
+            const lintResult = safeExec(exec, 'actionlint', input.workflowPaths, { cwd: input.root });
+            if (lintResult.status === 0) {
+                console.log(`  actionlint: passed (${input.workflowPaths.join(', ')})`);
+            }
+            else {
+                console.log('  actionlint: reported issues —');
+                for (const line of (lintResult.stdout || lintResult.stderr).split('\n')) {
+                    if (line.length > 0)
+                        console.log(`    ${line}`);
+                }
+            }
+        }
+    }
+    const nxVersionCheck = safeExec(exec, 'nx', ['--version'], { cwd: input.root });
+    if (nxVersionCheck.status !== 0) {
+        console.log('  nx graph: nx not found on PATH — skipped.');
+        console.log('    Run it via your package manager instead, e.g. `pnpm nx graph`, `yarn nx graph`, `bun nx graph` or `npm exec nx graph`.');
+        return;
+    }
+    const graphResult = safeExec(exec, 'nx', ['graph', `--file=${input.graphOutputFile}`], { cwd: input.root });
+    if (graphResult.status === 0) {
+        console.log(`  nx graph: valid (written to ${input.graphOutputFile})`);
+    }
+    else {
+        console.log('  nx graph: failed —');
+        for (const line of (graphResult.stdout || graphResult.stderr).split('\n')) {
+            if (line.length > 0)
+                console.log(`    ${line}`);
+        }
+    }
+}