@getrefino/cli 0.1.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Refino contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,90 @@
+# @getrefino/cli — the Refino installer
+
+**Refino lets site owners edit visible website copy in the browser while the
+repository stays the source of truth.**
+
+This package is how Refino is installed into a website. If you were asked to
+"install Refino", this is the package, and the command is:
+
+```bash
+npx @getrefino/cli init
+```
+
+The installed binary is named `refino`. **Refino** is the product; `getrefino`
+is only the npm namespace.
+
+## What Refino is
+
+The owner of a coded website opens their real site, clicks a headline or a
+paragraph, rewrites it in place, and presses Save. The change is committed to
+the website's own repository and the normal deployment pipeline ships it.
+
+- The copy lives in **one JSON file in the repository** (`content/copy.json` by
+  default). That file is the only source of truth.
+- An edit is a commit and a one-line diff. There is no CMS, no database and no
+  sync step.
+- It is builder-independent: it does not matter whether Claude Code, Cursor,
+  Codex, Lovable, Replit or a human wrote the site.
+- Removing Refino leaves the content exactly where it was.
+
+Refino changes words. Your coding agent keeps doing features, layouts and
+components.
+
+## Install into a site
+
+Run this in the website's repository:
+
+```bash
+npx @getrefino/cli init --agent
+```
+
+`init` inspects the repository (framework, router, routes, package manager,
+auth, server, hosting, git), scans the pages for visible copy, proposes stable
+ids, and writes:
+
+- the canonical copy file, with every selected string already in it
+- isolated setup files under `refino/`, plus `refino.config.json`
+- `.refino/plan.json` — the machine-readable migration plan
+- `.refino/AGENT_INSTRUCTIONS.md` — what a coding agent must do next
+
+Then check the result:
+
+```bash
+npx @getrefino/cli verify
+```
+
+## If you are a coding agent
+
+1. Run `npx @getrefino/cli init --agent` in the repository.
+2. Read `.refino/AGENT_INSTRUCTIONS.md` and `.refino/plan.json` and do exactly
+   what they say. **They are authoritative.** They were generated from an
+   inspection of this specific repository — do not invent integration steps,
+   do not add a second content store, and do not widen the scope.
+3. Run `npx @getrefino/cli verify` and fix only what it reports. Repeat until
+   it passes.
+
+## Commands
+
+| Command | What it does |
+| --- | --- |
+| `refino init` | Inspect, plan, and write setup files + agent instructions |
+| `refino inspect` | Report the repository facts only |
+| `refino scan` | List the visible copy it found, with reasons |
+| `refino plan` | Print the migration plan (`--format text\|json\|agent`) |
+| `refino verify` | Check an installation and say exactly what is missing |
+
+Every command takes `--json` for machine-readable output and `--cwd <dir>` to
+operate on another directory. `refino init --dry-run` shows what would be
+written without writing anything; no command ever overwrites an existing file.
+
+## Packages
+
+`@getrefino/cli` is a thin command layer over
+[`@getrefino/onboarding`](https://www.npmjs.com/package/@getrefino/onboarding).
+A site that has been onboarded ships only the runtime packages:
+
+- [`@getrefino/core`](https://www.npmjs.com/package/@getrefino/core) — content model and persistence contracts
+- [`@getrefino/react`](https://www.npmjs.com/package/@getrefino/react) — `RefinoProvider` and `EditableText`
+- [`@getrefino/github`](https://www.npmjs.com/package/@getrefino/github) — commits the copy file through the GitHub Contents API (self-hosted mode only)
+
+<https://refino.dev>

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { run } from "./cli.js";
+run(process.argv.slice(2))
+    .then((code) => {
+    process.exitCode = code;
+})
+    .catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export declare function run(argv: readonly string[]): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,282 @@
+/**
+ * Command layer over @getrefino/onboarding. Thin on purpose: every
+ * decision lives in the library so a hosted onboarding service can reuse it.
+ */
+import { writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parseArgs } from "node:util";
+import { INSTRUCTIONS_FILE, PLAN_FILE, TOOL_VERSION, appDirectory, applyPlan, inspectRepository, planMigration, renderAgentInstructions, scanCopy, verifyIntegration, } from "@getrefino/onboarding";
+import { bold, cyan, dim, formatApply, formatCandidates, formatInspection, formatPlanSummary, formatVerification, red, yellow } from "./format.js";
+const TAGLINE = "Refino lets site owners edit visible website copy in the browser while the repository stays the source of truth.";
+const HELP = `refino ${TOOL_VERSION}  (@getrefino/cli)
+
+${TAGLINE}
+
+It is not a CMS: the copy lives in one JSON file in the repository, an edit is a
+commit, and removing Refino leaves the content exactly where it was.
+
+Install into a site
+  npx @getrefino/cli init --agent     inspect the repo, write the setup files and
+                                      an authoritative plan + agent instructions
+  npx @getrefino/cli verify           check the result; repeat until it passes
+
+Usage
+  refino init     [--refino-site <id> [--refino-url <origin>]] [--route <path>]... [--all] [--agent | --dry-run | --plan] [--yes]
+  refino inspect  [--json]
+  refino scan     [--route <path>]... [--all] [--no-shared] [--json] [--include-excluded]
+  refino plan     [--route <path>]... [--all] [--format text|json|agent] [--out <file>]
+  refino verify   [--run] [--json]
+
+Options
+  --cwd <dir>           Repository to operate on (default: current directory)
+  --app <dir>           App directory inside a monorepo (auto-detected)
+  --route <path>        Route to migrate; repeatable (default: "/")
+  --all                 Every discovered route
+  --no-shared           Exclude shared chrome (layouts, nav, footer)
+  --content-file <p>    Where the canonical copy file lives (default: content/copy.json)
+  --refino-site <id>    Connect to Refino (hosted mode): the site id from the Refino dashboard.
+                        The site then needs no editor password, secret, repository token or server code.
+  --refino-url <origin> Refino app origin (default: https://app.refino.dev)
+  --agent               Write safe setup files + .refino/AGENT_INSTRUCTIONS.md
+  --dry-run             Show what --agent would write without writing
+  --plan                Print the plan only
+  --yes                 Do not prompt
+  --json                Machine-readable output
+  --run                 verify: also run the repository's typecheck/lint/test/build
+
+If you are a coding agent
+  1. npx @getrefino/cli init --agent          (inspect, plan, write setup files + instructions)
+  2. Read .refino/AGENT_INSTRUCTIONS.md and .refino/plan.json and do exactly what they say.
+     They are authoritative: do not invent integration steps of your own.
+  3. npx @getrefino/cli verify                (fix only what it reports, then run it again)
+`;
+function parse(argv) {
+    const { values, positionals } = parseArgs({
+        args: [...argv],
+        allowPositionals: true,
+        options: {
+            cwd: { type: "string" },
+            app: { type: "string" },
+            route: { type: "string", multiple: true },
+            all: { type: "boolean", default: false },
+            shared: { type: "boolean", default: true },
+            "no-shared": { type: "boolean", default: false },
+            "content-file": { type: "string" },
+            "refino-site": { type: "string" },
+            "refino-url": { type: "string" },
+            agent: { type: "boolean", default: false },
+            "dry-run": { type: "boolean", default: false },
+            plan: { type: "boolean", default: false },
+            yes: { type: "boolean", default: false, short: "y" },
+            json: { type: "boolean", default: false },
+            "include-excluded": { type: "boolean", default: false },
+            run: { type: "boolean", default: false },
+            format: { type: "string", default: "text" },
+            out: { type: "string" },
+            help: { type: "boolean", default: false, short: "h" },
+            version: { type: "boolean", default: false, short: "v" },
+        },
+    });
+    return {
+        command: positionals[0],
+        cwd: resolve(values.cwd ?? process.cwd()),
+        app: values.app,
+        routes: values.route,
+        all: values.all,
+        shared: !values["no-shared"],
+        contentFile: values["content-file"],
+        refinoSite: values["refino-site"],
+        refinoUrl: values["refino-url"],
+        agent: values.agent,
+        dryRun: values["dry-run"],
+        plan: values.plan,
+        yes: values.yes,
+        json: values.json,
+        includeExcluded: values["include-excluded"],
+        run: values.run,
+        format: values.format,
+        out: values.out,
+        help: values.help,
+        version: values.version,
+    };
+}
+function planOptions(args) {
+    const options = {};
+    if (args.routes)
+        options.routes = args.routes;
+    if (args.all)
+        options.all = true;
+    options.includeShared = args.shared;
+    if (args.contentFile)
+        options.contentFile = args.contentFile;
+    if (args.refinoSite)
+        options.refino = args.refinoUrl ? { siteId: args.refinoSite, appUrl: args.refinoUrl } : { siteId: args.refinoSite };
+    else if (args.refinoUrl)
+        throw new Error("--refino-url needs --refino-site.");
+    return options;
+}
+function inspect(args) {
+    return inspectRepository(args.cwd, args.app ? { app: args.app } : {});
+}
+function requireSupported(inspection) {
+    if (inspection.supported)
+        return true;
+    console.log(formatInspection(inspection));
+    console.log("");
+    console.log(red("This repository cannot be onboarded automatically. Refino v1 supports Next.js, Vite + React and plain React projects."));
+    console.log(dim("You can still integrate Refino by hand: https://refino.dev"));
+    return false;
+}
+async function prompt(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return (await rl.question(question)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+function writePlanOutputs(args, plan) {
+    if (!args.out)
+        return;
+    const content = args.format === "json" ? `${JSON.stringify(plan, null, 2)}\n` : args.format === "agent" ? renderAgentInstructions(plan) : formatPlanSummary(plan);
+    writeFileSync(resolve(args.cwd, args.out), content, "utf8");
+    console.log(dim(`Wrote ${args.out}`));
+}
+export async function run(argv) {
+    let args;
+    try {
+        args = parse(argv);
+    }
+    catch (error) {
+        console.error(error.message);
+        console.error(HELP);
+        return 2;
+    }
+    if (args.version) {
+        console.log(TOOL_VERSION);
+        return 0;
+    }
+    if (args.help || !args.command) {
+        console.log(HELP);
+        return args.command ? 0 : 2;
+    }
+    switch (args.command) {
+        case "inspect": {
+            const inspection = inspect(args);
+            console.log(args.json ? JSON.stringify(inspection, null, 2) : formatInspection(inspection));
+            return inspection.supported ? 0 : 1;
+        }
+        case "scan": {
+            const inspection = inspect(args);
+            if (!requireSupported(inspection))
+                return 1;
+            const options = { includeShared: args.shared };
+            if (args.routes)
+                options.routes = args.routes;
+            if (args.all)
+                options.all = true;
+            const result = scanCopy(inspection, options);
+            if (args.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                console.log(formatInspection(inspection));
+                console.log("");
+                console.log(bold(`Scanned ${result.filesScanned.length} files, ${result.candidates.length} strings found`));
+                console.log(formatCandidates(result.candidates, { includeExcluded: args.includeExcluded }));
+            }
+            return 0;
+        }
+        case "plan": {
+            const inspection = inspect(args);
+            if (!requireSupported(inspection))
+                return 1;
+            const plan = planMigration(inspection, planOptions(args));
+            if (args.format === "json")
+                console.log(JSON.stringify(plan, null, 2));
+            else if (args.format === "agent")
+                console.log(renderAgentInstructions(plan));
+            else {
+                console.log(formatInspection(inspection));
+                console.log("");
+                console.log(formatPlanSummary(plan));
+                console.log("");
+                console.log(formatCandidates(plan.copy, { includeExcluded: args.includeExcluded }));
+            }
+            writePlanOutputs(args, plan);
+            return 0;
+        }
+        case "init": {
+            console.log(bold(`Refino ${TOOL_VERSION}`));
+            console.log(TAGLINE);
+            console.log(dim("Copy lives in one JSON file in this repository. An edit is a commit. No CMS, no database, no sync."));
+            console.log("");
+            const inspection = inspect(args);
+            if (!requireSupported(inspection))
+                return 1;
+            const plan = planMigration(inspection, planOptions(args));
+            const appDir = appDirectory(inspection);
+            console.log(formatInspection(inspection));
+            console.log("");
+            console.log(formatPlanSummary(plan));
+            console.log("");
+            let mode;
+            if (args.agent)
+                mode = "agent";
+            else if (args.dryRun)
+                mode = "dry-run";
+            else if (args.plan)
+                mode = "plan";
+            else if (args.yes || !process.stdin.isTTY) {
+                mode = "dry-run";
+                console.log(dim("Non-interactive: showing a dry run. Pass --agent to write the setup files and agent instructions."));
+            }
+            else {
+                console.log(bold("Choose an onboarding method:"));
+                console.log("  1. Prepare for my coding agent (write safe setup files + AGENT_INSTRUCTIONS.md)");
+                console.log("  2. Show what option 1 would write (dry run)");
+                console.log("  3. Show the migration plan only");
+                const answer = await prompt("Enter 1, 2 or 3: ");
+                mode = answer === "1" ? "agent" : answer === "3" ? "plan" : "dry-run";
+            }
+            if (mode === "plan") {
+                console.log(formatCandidates(plan.copy));
+                return 0;
+            }
+            if (inspection.git.isRepository && inspection.git.clean === false && mode === "agent" && !args.yes) {
+                console.log(yellow("The working tree has uncommitted changes. Commit or stash first so the generated files are easy to review."));
+                const answer = await prompt("Continue anyway? (y/N) ");
+                if (answer.toLowerCase() !== "y")
+                    return 1;
+            }
+            const result = applyPlan(appDir, plan, { dryRun: mode === "dry-run" });
+            console.log(formatApply(result));
+            console.log("");
+            if (mode === "dry-run") {
+                console.log(dim("Nothing was written. Run `refino init --agent` to write these files."));
+                return 0;
+            }
+            console.log(bold("Next steps"));
+            if (result.installCommand)
+                console.log(`  1. ${result.installCommand}`);
+            console.log(`  ${result.installCommand ? "2" : "1"}. Give your coding agent this instruction:`);
+            console.log(cyan(`     "Read ${INSTRUCTIONS_FILE} and ${PLAN_FILE} in this repository and do exactly what they say. Then run npx @getrefino/cli verify and fix only what it reports."`));
+            console.log(`  ${result.installCommand ? "3" : "2"}. npx @getrefino/cli verify`);
+            return 0;
+        }
+        case "verify": {
+            const options = { run: args.run };
+            if (args.app)
+                options.app = args.app;
+            const result = verifyIntegration(args.cwd, options);
+            console.log(args.json ? JSON.stringify(result, null, 2) : formatVerification(result));
+            return result.ok ? 0 : 1;
+        }
+        default:
+            console.error(`Unknown command "${args.command}".`);
+            console.error(HELP);
+            return 2;
+    }
+}

package/dist/format.d.ts

@@ -0,0 +1,14 @@
+import type { ApplyResult, CopyCandidate, MigrationPlan, RepositoryInspection, VerificationResult } from "@getrefino/onboarding";
+export declare const bold: (text: string) => string;
+export declare const dim: (text: string) => string;
+export declare const green: (text: string) => string;
+export declare const yellow: (text: string) => string;
+export declare const red: (text: string) => string;
+export declare const cyan: (text: string) => string;
+export declare function formatInspection(inspection: RepositoryInspection): string;
+export declare function formatCandidates(candidates: readonly CopyCandidate[], options?: {
+    includeExcluded?: boolean;
+}): string;
+export declare function formatPlanSummary(plan: MigrationPlan): string;
+export declare function formatApply(result: ApplyResult): string;
+export declare function formatVerification(result: VerificationResult): string;

package/dist/format.js

@@ -0,0 +1,147 @@
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const paint = (code) => (text) => (useColor ? `[${code}m${text}` : text);
+export const bold = paint("1");
+export const dim = paint("2");
+export const green = paint("32");
+export const yellow = paint("33");
+export const red = paint("31");
+export const cyan = paint("36");
+function line(label, value) {
+    return `${dim(label.padEnd(26))}${value}`;
+}
+export function formatInspection(inspection) {
+    const rows = [];
+    rows.push(bold("Repository"));
+    rows.push(line("Root", inspection.root));
+    rows.push(line("App root", inspection.appRoot + (inspection.monorepo.detected ? `  (monorepo: ${inspection.monorepo.tool ?? "workspaces"}, ${inspection.monorepo.apps.length} packages)` : "")));
+    rows.push(line("Package manager", inspection.packageManager));
+    rows.push(line("Framework", inspection.framework === "unsupported" ? red("unsupported") : `${inspection.framework}${inspection.next ? ` ${inspection.next.version}` : inspection.vite ? ` (vite ${inspection.vite.version})` : ""}`));
+    rows.push(line("Router", inspection.router));
+    rows.push(line("Language", inspection.language));
+    rows.push(line("React", inspection.react ? inspection.react.version : "no"));
+    rows.push(line("Routes found", `${inspection.routes.length}${inspection.routes.length > 0 ? `  (${inspection.routes.slice(0, 6).map((route) => route.path).join(", ")}${inspection.routes.length > 6 ? ", …" : ""})` : ""}`));
+    rows.push(line("Layouts", inspection.layouts.join(", ") || "none"));
+    rows.push(line("Scripts", Object.entries(inspection.scripts).map(([key, value]) => `${key}=${JSON.stringify(value)}`).join(" ") || "none"));
+    rows.push(line("Content dirs", inspection.contentDirs.join(", ") || "none"));
+    rows.push(line("Auth", inspection.auth.libraries.join(", ") || "none detected"));
+    rows.push(line("Server", `${inspection.server.kind}${inspection.server.apiDir ? ` (${inspection.server.apiDir})` : ""}`));
+    rows.push(line("Hosting", inspection.hosting.provider ?? "not identified"));
+    rows.push(line("Git", inspection.git.isRepository ? `${inspection.git.branch ?? "?"}${inspection.git.clean === false ? " (uncommitted changes)" : ""}${inspection.git.github ? `  github:${inspection.git.github.owner}/${inspection.git.github.repo}` : ""}` : "not a repository"));
+    const ic = inspection.refino;
+    rows.push(line("Refino", ic.packages.length === 0 && !ic.contentFile ? "none" : `${ic.packages.map((p) => p.name).join(", ") || "no packages"}; content: ${ic.contentFile ?? "none"}; provider: ${ic.providerFiles.length > 0 ? "yes" : "no"}; endpoint: ${ic.endpointFiles.length > 0 ? "yes" : "no"}`));
+    if (!inspection.supported) {
+        rows.push("");
+        rows.push(red(bold("Automatic onboarding is unavailable:")));
+        for (const reason of inspection.unsupportedReasons)
+            rows.push(`  - ${reason}`);
+    }
+    return rows.join("\n");
+}
+function statusColor(status) {
+    switch (status) {
+        case "selected":
+            return green;
+        case "needs-review":
+            return yellow;
+        case "unsupported":
+            return red;
+        default:
+            return dim;
+    }
+}
+export function formatCandidates(candidates, options = {}) {
+    const rows = [];
+    const shown = candidates.filter((candidate) => options.includeExcluded || candidate.status !== "excluded");
+    let currentFile = "";
+    for (const candidate of shown) {
+        if (candidate.file !== currentFile) {
+            currentFile = candidate.file;
+            rows.push("");
+            rows.push(bold(currentFile) + dim(`  (${candidate.scope})`));
+        }
+        const status = statusColor(candidate.status)(candidate.status.padEnd(12));
+        const id = candidate.id ?? "(no id)";
+        const text = candidate.text.length > 56 ? `${candidate.text.slice(0, 55)}…` : candidate.text;
+        rows.push(`  ${status} ${cyan(id.padEnd(40))} ${dim(`:${candidate.line}`.padEnd(6))} ${JSON.stringify(text)}`);
+        if (candidate.status !== "selected")
+            rows.push(`  ${" ".repeat(12)} ${dim(candidate.reason)}`);
+    }
+    return rows.join("\n");
+}
+export function formatPlanSummary(plan) {
+    const rows = [];
+    rows.push(bold("Migration plan"));
+    rows.push(line("Scope", plan.scope.description));
+    rows.push(line("Content file", `${plan.contentFile.path}${plan.contentFile.exists ? " (exists, will merge)" : " (new)"}`));
+    rows.push(line("Provider", `${plan.integration.provider.file ?? "?"}  [${plan.integration.provider.strategy}]`));
+    rows.push(line("Endpoint", `${plan.integration.endpoint.path}  [${plan.integration.endpoint.kind}]`));
+    rows.push(line("Auth", `${plan.integration.auth.strategy}${plan.integration.auth.existing.length > 0 ? ` (existing: ${plan.integration.auth.existing.join(", ")})` : ""}`));
+    rows.push(line("Persistence", `local file in development; GitHub via ${plan.integration.persistence.github.envVars.join(", ")}`));
+    rows.push("");
+    rows.push(bold("Copy"));
+    rows.push(line("Selected", green(String(plan.summary.selected))));
+    rows.push(line("Needs review", yellow(String(plan.summary.needsReview))));
+    rows.push(line("Unsupported", red(String(plan.summary.unsupported))));
+    rows.push(line("Excluded (not copy)", dim(String(plan.summary.excluded))));
+    const scopes = Object.entries(plan.summary.byScope).sort(([a], [b]) => (a === "shared" ? 1 : b === "shared" ? -1 : a.localeCompare(b)));
+    if (scopes.length > 0) {
+        rows.push("");
+        rows.push(bold("Recommended first migration"));
+        for (const [scope, count] of scopes)
+            rows.push(`  - ${scope === "shared" ? "shared chrome (nav, footer, layouts)" : scope === "/" ? "homepage (/)" : scope}: ${count} strings`);
+    }
+    rows.push("");
+    rows.push(bold("Files"));
+    for (const file of plan.files)
+        rows.push(`  ${dim(file.action.padEnd(7))} ${file.path}  ${dim(file.description)}`);
+    if (plan.verification.commands.length > 0) {
+        rows.push("");
+        rows.push(bold("Verification"));
+        for (const command of plan.verification.commands)
+            rows.push(`  ${command}`);
+        rows.push(`  ${plan.verification.cli}`);
+    }
+    if (plan.unresolved.length > 0) {
+        rows.push("");
+        rows.push(bold(yellow("Needs a human or agent")));
+        for (const item of plan.unresolved)
+            rows.push(`  - ${item}`);
+    }
+    return rows.join("\n");
+}
+export function formatApply(result) {
+    const rows = [];
+    rows.push(bold(result.dryRun ? "Dry run: files that would be written" : "Files written"));
+    for (const file of result.written)
+        rows.push(`  ${green(file.action.padEnd(7))} ${file.path}  ${dim(file.description)}`);
+    if (result.skipped.length > 0) {
+        rows.push(bold("Skipped"));
+        for (const item of result.skipped)
+            rows.push(`  ${dim("skip".padEnd(7))} ${item.path}  ${dim(item.reason)}`);
+    }
+    return rows.join("\n");
+}
+export function formatVerification(result) {
+    const rows = [];
+    const mark = { pass: green("✔"), fail: red("✖"), warn: yellow("▲"), skip: dim("-") };
+    for (const check of result.checks) {
+        rows.push(`${mark[check.status]} ${check.message}`);
+        for (const detail of check.details ?? [])
+            rows.push(`    ${dim(detail)}`);
+        if (check.fix && check.status !== "pass")
+            rows.push(`    ${dim("fix:")} ${check.fix}`);
+    }
+    if (result.commands.length > 0) {
+        rows.push("");
+        rows.push(bold("Repository checks"));
+        for (const command of result.commands) {
+            if (!command.ran)
+                rows.push(`${dim("-")} ${command.command}  ${dim("(not run; pass --run)")}`);
+            else
+                rows.push(`${command.ok ? green("✔") : red("✖")} ${command.command}${command.ok ? "" : `\n${dim(command.output ?? "")}`}`);
+        }
+    }
+    rows.push("");
+    rows.push(result.ok ? green(bold("Verification passed.")) : red(bold("Verification found problems. Fix only what is listed above and run again.")));
+    return rows.join("\n");
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@getrefino/cli",
+  "version": "0.1.0-rc.1",
+  "description": "Refino installer. Run `npx @getrefino/cli init` in a website's repository to let its owner edit visible copy in the browser while Git remains the source of truth. Inspects the repo, writes an authoritative migration plan and instructions for a coding agent, then verifies the result.",
+  "keywords": [
+    "refino",
+    "install",
+    "installer",
+    "cli",
+    "copy",
+    "content",
+    "visual-editing",
+    "inline-editing",
+    "cms-alternative",
+    "react",
+    "nextjs",
+    "agent"
+  ],
+  "license": "MIT",
+  "homepage": "https://refino.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/forant/inline-copy.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": false
+  },
+  "type": "module",
+  "bin": {
+    "refino": "./dist/bin.js"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@getrefino/onboarding": "0.1.0-rc.1"
+  },
+  "devDependencies": {
+    "@types/node": "22.20.2",
+    "vitest": "5.0.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/bin.js",
+    "dev": "tsc -p tsconfig.build.json --watch --preserveWatchOutput",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist"
+  }
+}