@bluenyang/reins 0.0.0-stage → 0.1.0

package/cli/dist/commands/migrate.js

@@ -0,0 +1,122 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmdirSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { applyBlocks, parseBlocks, swapSections } from '../lib/blocks.js';
+import { generation } from '../lib/detect.js';
+import { repoRoot } from '../lib/git.js';
+import { convertWorkToTicket, planMigration } from '../lib/migrate-plan.js';
+import { packageHarness } from '../lib/upstream.js';
+import { ROADMAP_STUB, runInstall } from './install.js';
+const pad = (n) => String(n).padStart(2, '0');
+const stampOf = (d) => `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}-${pad(d.getHours())}${pad(d.getMinutes())}`;
+function removeEmptyDirs(dir) {
+    if (!existsSync(dir) || !statSync(dir).isDirectory())
+        return;
+    for (const e of readdirSync(dir))
+        removeEmptyDirs(join(dir, e));
+    if (readdirSync(dir).length === 0)
+        rmdirSync(dir);
+}
+/** `reins migrate <tier>` (design §7): install if needed, move the old workspace, swap AGENTS.md sections. Idempotent. */
+export async function runMigrate(o) {
+    const root = repoRoot(o.cwd ?? process.cwd());
+    const gen = generation(root);
+    const res = {
+        root,
+        generation: gen,
+        moves: [],
+        agents: { swapped: [], inserted: [] },
+        report: [],
+    };
+    if (gen === 'none')
+        return { ...res, refused: 'no existing harness or workspace here — use `reins install`' };
+    // 1. make sure the target layout exists (install is idempotent)
+    if (!o.dryRun) {
+        const inst = await runInstall({
+            tier: o.tier,
+            mode: o.mode,
+            asker: o.asker,
+            cwd: root,
+            detectVendors: o.detectVendors,
+            now: o.now,
+            overExisting: true,
+        });
+        if (inst.refused)
+            return { ...res, refused: inst.refused };
+        res.report.push(...inst.notes.filter((n) => !n.startsWith('next:') && !n.includes('managed') && !n.includes('not placed')));
+    }
+    // 2. move the old workspace
+    const plan = planMigration(root);
+    res.report.push(...plan.report);
+    for (const m of plan.moves) {
+        const from = join(root, m.from);
+        const to = join(root, m.to);
+        if (o.dryRun) {
+            res.moves.push({ ...m, result: 'planned' });
+            continue;
+        }
+        mkdirSync(dirname(to), { recursive: true });
+        const src = readFileSync(from);
+        if (m.action === 'ticket') {
+            writeFileSync(to, convertWorkToTicket(src.toString('utf8'), m.from.split('/').pop() ?? ''));
+            unlinkSync(from);
+            res.moves.push({ ...m, result: 'converted' });
+        }
+        else if (!existsSync(to) || readFileSync(to, 'utf8') === ROADMAP_STUB) {
+            renameSync(from, to);
+            res.moves.push({ ...m, result: 'moved' });
+        }
+        else if (Buffer.compare(readFileSync(to), src) === 0) {
+            unlinkSync(from);
+            res.moves.push({ ...m, result: 'same' });
+        }
+        else {
+            const alt = to.replace(/(\.[^./]+)?$/, '.from-ai$1');
+            renameSync(from, alt);
+            res.moves.push({ ...m, to: alt.slice(root.length + 1), result: 'kept-both' });
+            res.report.push(`${m.to} already existed — the old file is next to it as ${alt.slice(root.length + 1)}`);
+        }
+    }
+    if (!o.dryRun)
+        removeEmptyDirs(join(root, '.ai'));
+    // 3. AGENTS.md: sections reins owns become managed blocks; the originals are kept locally
+    const agentsPath = join(root, 'AGENTS.md');
+    if (existsSync(agentsPath)) {
+        const up = parseBlocks(readFileSync(join(packageHarness(), 'templates/agents-md-blocks.md'), 'utf8'));
+        const before = readFileSync(agentsPath, 'utf8');
+        const swap = swapSections(before, up);
+        const placed = applyBlocks(swap.text, up);
+        res.agents = { swapped: swap.swapped, inserted: placed.inserted };
+        if (placed.text !== before && !o.dryRun) {
+            writeFileSync(agentsPath, placed.text);
+            if (swap.removed) {
+                const keep = join(root, '.loctx/context/agents-md.before.md');
+                mkdirSync(dirname(keep), { recursive: true });
+                const prev = existsSync(keep) ? `${readFileSync(keep, 'utf8')}\n\n` : '';
+                writeFileSync(keep, `${prev}<!-- replaced by reins migrate, ${stampOf(o.now ?? new Date())} -->\n${swap.removed}\n`);
+                res.report.push('AGENTS.md: the replaced sections are in .loctx/context/agents-md.before.md — move project-specific rules back outside the blocks');
+            }
+        }
+    }
+    // 4. record, only when something happened
+    const happened = res.moves.length > 0 || res.agents.swapped.length > 0;
+    if (happened && !o.dryRun) {
+        res.history = `.loctx/history/${stampOf(o.now ?? new Date())}_migrate-${o.tier}.md`;
+        const count = (r) => res.moves.filter((m) => m.result === r).length;
+        writeFileSync(join(root, res.history), [
+            `decisions: migrate-${o.tier}`,
+            '',
+            `# reins migrate ${o.tier} — from ${gen}`,
+            '',
+            `- moved ${count('moved')} · converted to tickets ${count('converted')} · identical ${count('same')} · kept both ${count('kept-both')}`,
+            `- AGENTS.md: swapped ${res.agents.swapped.join(', ') || 'none'}; inserted ${res.agents.inserted.join(', ') || 'none'}`,
+            '',
+            '## for a person to look at',
+            ...res.report.map((r) => `- ${r}`),
+            '',
+            '## moves',
+            ...res.moves.map((m) => `- ${m.from} → ${m.to} (${m.result})`),
+            '',
+        ].join('\n'));
+    }
+    return res;
+}

package/cli/dist/lib/ask.js

@@ -0,0 +1,27 @@
+import { createInterface } from 'node:readline/promises';
+export async function stdinAsker() {
+    if (process.stdin.isTTY) {
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        return {
+            async ask(q, d) {
+                const a = (await rl.question(`${q} [${d}] `)).trim();
+                return a || d;
+            },
+            close: () => rl.close(),
+        };
+    }
+    const chunks = [];
+    for await (const c of process.stdin)
+        chunks.push(c);
+    const lines = Buffer.concat(chunks).toString('utf8').split('\n');
+    return {
+        async ask(q, d) {
+            const a = (lines.shift() ?? '').trim();
+            process.stderr.write(`${q} [${d}] ${a}\n`);
+            return a || d;
+        },
+        close: () => { },
+    };
+}
+/** Auto mode and tests: every question takes its default. */
+export const defaultsAsker = { ask: async (_q, d) => d, close: () => { } };

package/cli/dist/lib/blocks.js

@@ -0,0 +1,93 @@
+const BLOCK_RE = /<!-- reins:begin ([a-z-]+) v=([^ ]+) -->[\s\S]*?<!-- reins:end \1 -->/g;
+const OVERRIDE_RE = /<!-- reins:override ([a-z-]+) -->/g;
+export function parseBlocks(text) {
+    return [...text.matchAll(BLOCK_RE)].map((m) => ({
+        name: m[1] ?? '',
+        version: m[2] ?? '',
+        body: m[0],
+    }));
+}
+export function overrides(text) {
+    return new Set([...text.matchAll(OVERRIDE_RE)].map((m) => m[1] ?? ''));
+}
+/** The first `## ` heading inside a block, e.g. "Workflow". */
+function headingOf(block) {
+    return /^## (.+)$/m.exec(block.body)?.[1]?.trim() ?? null;
+}
+/** Text with every managed block removed — what the project wrote. */
+function outside(text) {
+    return text.replace(BLOCK_RE, '');
+}
+/**
+ * Put the upstream blocks into an AGENTS.md. Existing blocks are replaced in place; an overridden block is
+ * left alone; a block whose heading the project already has outside any block is skipped (migrate replaces it).
+ * New blocks go after the first H1 (notice) or at the end.
+ */
+export function applyBlocks(text, upstream) {
+    const res = { text, inserted: [], replaced: [], skipped: [] };
+    const present = new Map(parseBlocks(text).map((b) => [b.name, b]));
+    const over = overrides(text);
+    for (const b of upstream) {
+        if (over.has(b.name)) {
+            res.skipped.push({ name: b.name, why: 'overridden by the project' });
+            continue;
+        }
+        const cur = present.get(b.name);
+        if (cur) {
+            if (cur.body !== b.body) {
+                res.text = res.text.replace(cur.body, b.body);
+                res.replaced.push(b.name);
+            }
+            continue;
+        }
+        const h = headingOf(b);
+        if (h && new RegExp(`^## ${h}\\s*$`, 'm').test(outside(res.text))) {
+            res.skipped.push({
+                name: b.name,
+                why: `the project already has a "## ${h}" section — \`reins migrate\` replaces it`,
+            });
+            continue;
+        }
+        if (b.name === 'notice') {
+            const h1 = /^# .*$/m.exec(res.text);
+            res.text = h1
+                ? `${res.text.slice(0, h1.index + h1[0].length)}\n\n${b.body}\n${res.text.slice(h1.index + h1[0].length)}`
+                : `${b.body}\n\n${res.text}`;
+        }
+        else
+            res.text = `${res.text.replace(/\s*$/, '')}\n\n${b.body}\n`;
+        res.inserted.push(b.name);
+    }
+    return res;
+}
+/**
+ * Migrate's half of the managed-block story (design §7): a project section whose heading an upstream block
+ * owns (`## Workflow`, `## Skills`, `## Language`) is replaced by that block. The section runs from its
+ * heading to the next heading of the same or a higher level. The originals are returned so nothing is lost.
+ */
+export function swapSections(text, upstream) {
+    let out = text;
+    const swapped = [];
+    const removed = [];
+    const present = new Set(parseBlocks(text).map((b) => b.name));
+    for (const b of upstream) {
+        if (present.has(b.name))
+            continue;
+        const h = headingOf(b);
+        if (!h)
+            continue;
+        const re = new RegExp(`^## ${h.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`, 'm');
+        const m = re.exec(out);
+        if (!m)
+            continue;
+        const start = m.index;
+        const rest = out.slice(start + m[0].length);
+        // a section ends at the next heading of the same or higher level, or where a managed block begins
+        const next = /^(?:#{1,2} |<!-- reins:begin )/m.exec(rest);
+        const end = next ? start + m[0].length + next.index : out.length;
+        removed.push(out.slice(start, end).trimEnd());
+        out = `${out.slice(0, start)}${b.body}\n\n${out.slice(end).replace(/^\n+/, '')}`.replace(/\n{3,}/g, '\n\n');
+        swapped.push(b.name);
+    }
+    return { text: out.replace(/\s*$/, '\n'), swapped, removed: removed.join('\n\n') };
+}

package/cli/dist/lib/detect.js

@@ -0,0 +1,105 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+export function generation(root) {
+    const agents = join(root, 'AGENTS.md');
+    const hasAgents = existsSync(agents);
+    if (hasAgents &&
+        readFileSync(agents, 'utf8').includes('<!-- reins:begin') &&
+        existsSync(join(root, '.agents/harness')))
+        return 'reins';
+    const skills = join(root, '.claude/skills');
+    const skillDirs = existsSync(skills) ? readdirSync(skills) : [];
+    if (skillDirs.length >= 10 && skillDirs.some((s) => s === 'work-cicd-to' || s === 'go-flow'))
+        return 'gen4';
+    if (existsSync(join(root, '.claude/commands')))
+        return 'gen3';
+    if (hasAgents)
+        return 'gen2';
+    if (existsSync(join(root, '.ai')))
+        return 'gen1';
+    return 'none';
+}
+function onPath(bin) {
+    try {
+        execFileSync(process.platform === 'win32' ? 'where' : 'which', [bin], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function vendors() {
+    return [
+        { name: 'claude', cli: 'claude', detected: onPath('claude') },
+        { name: 'openai', cli: 'codex', detected: onPath('codex') },
+        { name: 'google', cli: 'agy', detected: onPath('agy') || onPath('gemini') },
+        { name: 'cursor', cli: 'cursor-agent', detected: onPath('cursor-agent') },
+    ];
+}
+export function stacks(root) {
+    const out = [];
+    if (existsSync(join(root, 'package.json')))
+        out.push('node');
+    if (existsSync(join(root, 'go.mod')))
+        out.push('go');
+    if (existsSync(join(root, 'build.gradle.kts')) || existsSync(join(root, 'build.gradle')))
+        out.push('gradle');
+    if (existsSync(join(root, 'pyproject.toml')) || existsSync(join(root, 'requirements.txt')))
+        out.push('python');
+    return out;
+}
+export function runner(root) {
+    if (existsSync(join(root, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(root, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(join(root, 'package-lock.json')) || existsSync(join(root, 'package.json')))
+        return 'npm';
+    if (existsSync(join(root, 'Makefile')))
+        return 'make';
+    return null;
+}
+const MUTATING = /--fix\b|--write\b|\bfmt\b(?!:check)|(^|\s)format(\s|$)/;
+/**
+ * The PM's discovery step 2–3 (design §5): read the project's scripts, drop mutating ones,
+ * prefer the aggregate `check` the hooks and CI already call.
+ */
+export function discoverGates(root) {
+    const res = { gates: [], excluded: [] };
+    const run = runner(root);
+    const pkgPath = join(root, 'package.json');
+    if (run && run !== 'make' && existsSync(pkgPath)) {
+        const scripts = JSON.parse(readFileSync(pkgPath, 'utf8')).scripts ??
+            {};
+        const cmd = (s) => (run === 'npm' ? `npm run ${s}` : `${run} ${s}`);
+        for (const [name, body] of Object.entries(scripts))
+            if (MUTATING.test(body) && !/check/.test(name))
+                res.excluded.push({ name, cmd: body, why: 'mutates files (--fix/--write) — not a gate' });
+        const pick = (names) => names.find((n) => n in scripts && !MUTATING.test(scripts[n] ?? ''));
+        const check = pick(['check', 'verify', 'ci', 'lint:check']) ?? null;
+        if (check)
+            res.gates.push({ name: 'check', cmd: cmd(check), from: `package.json#scripts.${check}` });
+        const test = check && /\btest\b/.test(scripts[check] ?? '') ? null : pick(['test', 'test:unit']);
+        if (test)
+            res.gates.push({ name: 'test', cmd: cmd(test), from: `package.json#scripts.${test}` });
+        const build = pick(['build']);
+        if (build)
+            res.gates.push({ name: 'build', cmd: cmd(build), from: 'package.json#scripts.build' });
+        const e2e = pick(['test:e2e', 'e2e']);
+        if (e2e)
+            res.gates.push({
+                name: 'e2e',
+                cmd: cmd(e2e),
+                from: `package.json#scripts.${e2e}`,
+                optional: true,
+            });
+    }
+    else if (run === 'make') {
+        const mk = readFileSync(join(root, 'Makefile'), 'utf8');
+        for (const t of ['check', 'test', 'build'])
+            if (new RegExp(`^${t}:`, 'm').test(mk))
+                res.gates.push({ name: t, cmd: `make ${t}`, from: `Makefile:${t}` });
+    }
+    return res;
+}

package/cli/dist/lib/fsx.js

@@ -0,0 +1,36 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+export function apply(root, writes, dryRun) {
+    const out = { created: [], changed: [], unchanged: [] };
+    for (const w of writes) {
+        const abs = join(root, w.path);
+        const exists = existsSync(abs);
+        if (exists && readFileSync(abs, 'utf8') === w.content) {
+            out.unchanged.push(w.path);
+            continue;
+        }
+        (exists ? out.changed : out.created).push(w.path);
+        if (!dryRun) {
+            mkdirSync(dirname(abs), { recursive: true });
+            writeFileSync(abs, w.content);
+        }
+    }
+    return out;
+}
+/** Every file under `dir`, as paths relative to `dir`. */
+export function listFiles(dir) {
+    const out = [];
+    const walk = (d) => {
+        if (!existsSync(d))
+            return;
+        for (const e of readdirSync(d)) {
+            const p = join(d, e);
+            if (statSync(p).isDirectory())
+                walk(p);
+            else
+                out.push(relative(dir, p));
+        }
+    };
+    walk(dir);
+    return out.toSorted();
+}

package/cli/dist/lib/git.js

@@ -0,0 +1,30 @@
+import { execFileSync } from 'node:child_process';
+function git(args, cwd) {
+    return execFileSync('git', args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+}
+export function stagedFiles(cwd) {
+    const out = git(['diff', '--cached', '--name-only', '--diff-filter=ACMR'], cwd);
+    return out ? out.split('\n') : [];
+}
+export function currentBranch(cwd) {
+    return git(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+}
+export function isAncestor(ancestor, descendant, cwd) {
+    try {
+        execFileSync('git', ['merge-base', '--is-ancestor', ancestor, descendant], {
+            cwd,
+            stdio: 'ignore',
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function repoRoot(cwd) {
+    return git(['rev-parse', '--show-toplevel'], cwd);
+}

package/cli/dist/lib/glob.js

@@ -0,0 +1,30 @@
+/** Minimal glob → RegExp: `**` any path, `*` within a segment, `?` one char. Matches whole path. */
+export function globToRegExp(glob) {
+    let re = '';
+    for (let i = 0; i < glob.length; i++) {
+        const c = glob[i];
+        if (c === '*') {
+            if (glob[i + 1] === '*') {
+                re += '.*';
+                i++;
+                if (glob[i + 1] === '/')
+                    i++;
+            }
+            else
+                re += '[^/]*';
+        }
+        else if (c === '?')
+            re += '[^/]';
+        else if (c && '.+^${}()|[]\\'.includes(c))
+            re += `\\${c}`;
+        else
+            re += c;
+    }
+    return new RegExp(`^(?:.*/)?${re}$`);
+}
+export function matchesAny(path, globs) {
+    for (const g of globs)
+        if (globToRegExp(g).test(path))
+            return g;
+    return null;
+}

package/cli/dist/lib/harness.js

@@ -0,0 +1,33 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from 'yaml';
+/**
+ * Where the harness sources live: an installed project has `.agents/harness/`;
+ * this repository (the upstream) keeps them at `harness/`.
+ */
+export function harnessDir(root) {
+    for (const d of ['.agents/harness', 'harness']) {
+        if (existsSync(join(root, d, 'policy')))
+            return join(root, d);
+    }
+    return null;
+}
+export function readYaml(path) {
+    return parse(readFileSync(path, 'utf8'));
+}
+export function redLines(dir) {
+    return readYaml(join(dir, 'policy', 'common-red-lines.yaml')).rules;
+}
+export function stops(dir) {
+    return readYaml(join(dir, 'policy', 'stops.yaml')).stops;
+}
+/** Secret patterns from red line C4, or null when there is no harness to read. */
+export function secretPolicy(root) {
+    const dir = harnessDir(root);
+    if (!dir)
+        return null;
+    const c4 = redLines(dir).find((r) => r.id === 'C4');
+    if (!c4?.patterns)
+        return null;
+    return { patterns: c4.patterns, allowed: c4.allowed ?? [] };
+}