@getrefino/onboarding 0.1.0-rc.1

package/dist/types.d.ts

@@ -0,0 +1,286 @@
+/**
+ * Structured results shared by the CLI and any future hosted onboarding.
+ * Everything here is plain JSON-serializable data. No secrets, ever.
+ */
+export type PackageManager = "pnpm" | "npm" | "yarn" | "bun" | "unknown";
+export type Framework = "next" | "vite-react" | "react" | "unsupported";
+export type Router = "next-app" | "next-pages" | "react-router" | "single-page" | "unknown";
+export type Language = "typescript" | "javascript";
+export interface DetectedPackage {
+    readonly name: string;
+    readonly version: string;
+    /** Where the dependency was declared. */
+    readonly kind: "dependencies" | "devDependencies";
+}
+export interface ScriptSet {
+    readonly build?: string;
+    readonly test?: string;
+    readonly typecheck?: string;
+    readonly lint?: string;
+    readonly dev?: string;
+}
+export interface GitState {
+    readonly isRepository: boolean;
+    readonly branch: string | null;
+    readonly clean: boolean | null;
+    readonly remote: string | null;
+    readonly github: {
+        readonly owner: string;
+        readonly repo: string;
+    } | null;
+}
+export interface RouteInfo {
+    /** URL path, e.g. "/" or "/blog/[slug]". */
+    readonly path: string;
+    /** Repository-relative file that renders the route. */
+    readonly file: string;
+}
+export interface RepositoryInspection {
+    readonly root: string;
+    /** Repository-relative path of the app being onboarded ("." for single apps). */
+    readonly appRoot: string;
+    readonly monorepo: {
+        readonly detected: boolean;
+        readonly tool: "pnpm" | "yarn" | "npm" | "turbo" | "lerna" | "nx" | null;
+        readonly apps: readonly string[];
+    };
+    readonly packageManager: PackageManager;
+    readonly packageJson: string | null;
+    readonly packageName: string | null;
+    readonly framework: Framework;
+    readonly router: Router;
+    readonly language: Language;
+    readonly react: DetectedPackage | null;
+    readonly next: DetectedPackage | null;
+    /** Facts read from next.config.*; `output: "export"` means a static site without route handlers. */
+    readonly nextConfig: {
+        readonly file: string | null;
+        readonly output: "export" | "standalone" | null;
+    };
+    readonly vite: DetectedPackage | null;
+    readonly typescript: DetectedPackage | null;
+    readonly sourceDir: string;
+    readonly routesDir: string | null;
+    readonly routes: readonly RouteInfo[];
+    readonly layouts: readonly string[];
+    readonly entry: string | null;
+    readonly scripts: ScriptSet;
+    readonly contentDirs: readonly string[];
+    readonly refino: {
+        readonly packages: readonly DetectedPackage[];
+        readonly contentFile: string | null;
+        readonly configFile: string | null;
+        readonly providerFiles: readonly string[];
+        readonly endpointFiles: readonly string[];
+        readonly editableTextFiles: readonly string[];
+    };
+    readonly auth: {
+        readonly libraries: readonly string[];
+        readonly middlewareFile: string | null;
+        readonly notes: readonly string[];
+    };
+    readonly server: {
+        readonly capable: boolean;
+        readonly kind: "next-route-handlers" | "next-api-routes" | "custom-server" | "static" | "unknown";
+        readonly apiDir: string | null;
+        /** Runtime facts that hold whoever serves the copy API. Safe in either mode. */
+        readonly notes: readonly string[];
+        /**
+         * What a deployment that runs its own editor endpoints must do about
+         * those facts. A Refino-hosted plan never carries these: Refino serves
+         * the copy API and the site has no endpoints of its own.
+         */
+        readonly selfHosted: readonly string[];
+    };
+    readonly hosting: {
+        readonly provider: string | null;
+        readonly evidence: readonly string[];
+    };
+    readonly git: GitState;
+    readonly supported: boolean;
+    readonly unsupportedReasons: readonly string[];
+}
+export type CopyClassification = "visible-text" | "display-prop" | "data-object" | "mixed-markup" | "dynamic" | "ui-text" | "accessibility" | "metadata" | "developer-text" | "decorative" | "uncertain";
+export type CandidateStatus = "selected" | "needs-review" | "unsupported" | "excluded";
+export interface CopyCandidate {
+    /** Proposed content ID, or null when nothing sensible could be derived. */
+    readonly id: string | null;
+    readonly text: string;
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+    /** How the string appears in source. */
+    readonly source: "jsx-text" | "jsx-child-literal" | "jsx-attribute" | "data-object";
+    /** Enclosing JSX element tag or component (for jsx sources). */
+    readonly element: string | null;
+    /** Attribute or object key name (for attribute and data sources). */
+    readonly key: string | null;
+    readonly component: string | null;
+    /** Route this file belongs to, or "shared". */
+    readonly scope: string;
+    readonly classification: CopyClassification;
+    readonly status: CandidateStatus;
+    readonly reason: string;
+}
+export interface ScanResult {
+    readonly filesScanned: readonly string[];
+    readonly candidates: readonly CopyCandidate[];
+}
+export type HostKind = 
+/** Refino-hosted: the customer site has no endpoint files; Refino serves the copy API. */
+"refino-hosted" | "next-route-handlers" | "cloudflare-pages-functions" | "vercel-functions" | "netlify-functions" | "next-api-routes" | "custom-server" | "unknown-serverless";
+export interface HostIntegration {
+    readonly kind: HostKind;
+    /** Hosting provider the choice was based on, when identified. */
+    readonly provider: string | null;
+    /** True when the tool writes both endpoint files itself; false when the agent adapts request-handlers. */
+    readonly generated: boolean;
+    /** Repository-relative file serving /api/copy (in hosted mode: the Refino copy API URL). */
+    readonly copyEndpoint: string;
+    /** Repository-relative file serving /api/edit-session (in hosted mode: the Refino token exchange URL). */
+    readonly sessionEndpoint: string;
+    /** Runtime facts the agent and the owner need (filesystem, compatibility flags, variables). */
+    readonly notes: readonly string[];
+}
+export interface PlannedFile {
+    readonly path: string;
+    readonly action: "create" | "merge" | "append" | "modify";
+    readonly description: string;
+}
+export interface MigrationPlan {
+    readonly version: 1;
+    readonly generatedAt: string;
+    readonly tool: {
+        readonly name: string;
+        readonly version: string;
+    };
+    readonly repository: {
+        readonly root: string;
+        readonly appRoot: string;
+        readonly framework: Framework;
+        readonly router: Router;
+        readonly language: Language;
+        readonly packageManager: PackageManager;
+        readonly react: string | null;
+        readonly next: string | null;
+        readonly scripts: ScriptSet;
+        readonly git: GitState;
+        readonly hosting: string | null;
+        readonly auth: readonly string[];
+        readonly server: RepositoryInspection["server"]["kind"];
+        /**
+         * Why the server capability is what it is (for example "next.config.mjs
+         * sets output: 'export'"), plus, in self-hosted mode only, what to do
+         * about it. Hosted plans carry the facts alone.
+         */
+        readonly serverNotes: readonly string[];
+    };
+    readonly scope: {
+        readonly routes: readonly string[];
+        readonly includeShared: boolean;
+        readonly description: string;
+    };
+    readonly contentFile: {
+        readonly path: string;
+        readonly exists: boolean;
+    };
+    readonly configFile: {
+        readonly path: string;
+        readonly exists: boolean;
+    };
+    readonly integration: {
+        readonly provider: {
+            readonly file: string | null;
+            readonly strategy: string;
+            readonly notes: readonly string[];
+        };
+        readonly endpoint: {
+            readonly path: string;
+            readonly kind: string;
+            readonly notes: readonly string[];
+        };
+        /** Which host path serves /api/copy and /api/edit-session, and whether the tool generates it. */
+        readonly host: HostIntegration;
+        readonly auth: {
+            readonly strategy: string;
+            readonly existing: readonly string[];
+            readonly notes: readonly string[];
+        };
+        readonly persistence: {
+            readonly local: {
+                readonly adapter: string;
+                readonly filePath: string;
+            };
+            readonly github: {
+                readonly adapter: string;
+                readonly envVars: readonly string[];
+            };
+        };
+        readonly boilerplateDir: string;
+    };
+    readonly copy: readonly CopyCandidate[];
+    readonly summary: {
+        readonly selected: number;
+        readonly needsReview: number;
+        readonly unsupported: number;
+        readonly excluded: number;
+        readonly byScope: Readonly<Record<string, number>>;
+        readonly byFile: Readonly<Record<string, number>>;
+    };
+    /** Set when the site is connected to Refino: hosted authentication and copy API, no site secrets. */
+    readonly refino: RefinoSite | null;
+    readonly files: readonly PlannedFile[];
+    readonly verification: {
+        readonly commands: readonly string[];
+        readonly cli: string;
+    };
+    readonly unresolved: readonly string[];
+}
+/** Public identifiers of a site connected to Refino. Neither is a secret. */
+export interface RefinoSite {
+    readonly siteId: string;
+    /** Origin of the Refino app, e.g. "https://app.refino.dev". */
+    readonly appUrl: string;
+}
+export interface PlanOptions {
+    /** Connect to Refino (hosted mode): the site id from the Refino dashboard, and optionally the app origin. */
+    readonly refino?: {
+        readonly siteId: string;
+        readonly appUrl?: string;
+    };
+    /** Routes to migrate. Defaults to ["/"] when the route exists. */
+    readonly routes?: readonly string[];
+    /** Migrate every discovered route. */
+    readonly all?: boolean;
+    /** Include shared chrome (layouts, nav, footer). Default true. */
+    readonly includeShared?: boolean;
+    readonly contentFile?: string;
+    readonly now?: Date;
+}
+export interface ApplyResult {
+    readonly dryRun: boolean;
+    readonly written: readonly PlannedFile[];
+    readonly skipped: readonly {
+        readonly path: string;
+        readonly reason: string;
+    }[];
+    readonly installCommand: string | null;
+}
+export type CheckStatus = "pass" | "fail" | "warn" | "skip";
+export interface VerificationCheck {
+    readonly id: string;
+    readonly status: CheckStatus;
+    readonly message: string;
+    readonly details?: readonly string[];
+    readonly fix?: string;
+}
+export interface VerificationResult {
+    readonly ok: boolean;
+    readonly checks: readonly VerificationCheck[];
+    readonly commands: readonly {
+        readonly command: string;
+        readonly ran: boolean;
+        readonly ok: boolean | null;
+        readonly output?: string;
+    }[];
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Structured results shared by the CLI and any future hosted onboarding.
+ * Everything here is plain JSON-serializable data. No secrets, ever.
+ */
+export {};

package/dist/verify.d.ts

@@ -0,0 +1,8 @@
+import type { InspectOptions } from "./inspect.js";
+import type { VerificationResult } from "./types.js";
+export interface VerifyOptions extends InspectOptions {
+    /** Run the repository's typecheck/lint/test/build scripts. */
+    readonly run?: boolean;
+    readonly contentFile?: string;
+}
+export declare function verifyIntegration(rootPath: string, options?: VerifyOptions): VerificationResult;