@reticlehq/server 2.13.0 → 2.14.0

package/dist/init/mcp.js

@@ -1,129 +0,0 @@
-/**
- * Global (user-scope) MCP registration for `reticle init`. The bridge + MCP server is a single
- * process that serves every project, so it is registered ONCE at user scope — not per-project via
- * a checked-in `.mcp.json`. We shell out to the official `claude mcp add -s user` CLI rather than
- * hand-editing `~/.claude.json` (a large stateful file). When the `claude` CLI is absent we print a
- * manual instruction instead.
- *
- * The registration is intentionally PORTLESS — `npx @reticlehq/server mcp`, never `--port N`. A single
- * global entry serves every project, so baking a port into it would pin every project to one port
- * and defeat per-project isolation. Instead `reticle mcp` resolves the port at runtime from the
- * project's `.reticle.json` in its CWD (see cli-port.ts). The port belongs to the project, not the
- * global agent config.
- */
-import { RETICLE_NPM_PACKAGE } from '../version/server-version.js';
-// The name is a wire identity and lives in the contract; re-exported here so the registration writers
-// below (and their tests) keep reading it from the module that USES it.
-export { MCP_SERVER_NAME } from '@reticlehq/core';
-import { MCP_SERVER_NAME } from '@reticlehq/core';
-/**
- * The registered command is STILL bare `npx` on every platform, deliberately.
- *
- * Windows is most of Reticle's users and, when this was written, had no CI. There is Windows CI
- * now, so the `cmd /c` fallback is testable. Defaulting the majority platform to that launch
- * command is still the riskier change: `.cmd` has spawn caveats in some hosts, and a registration
- * that works on the machines we can test can still fail in the hosts we cannot. So the fallback
- * stays documented rather than defaulted.
- *
- * What DID change is when it is printed. `mcpManual` used to run only when the `claude` CLI was
- * absent. The reported Windows install had `claude mcp add` succeed, so the one paragraph that
- * would have unblocked zero tools never appeared. `mcpWindowsNote` is that paragraph, and init
- * prints it on every Windows run — including the ones that look like a clean registration.
- */
-export const NPX = 'npx';
-// The `reticle` bin lives in the server package, so `npx <pkg> mcp` runs the bridge without the
-// retired `core` umbrella. Sourced from the single derived identity so it can never drift.
-const RETICLE_PACKAGE = RETICLE_NPM_PACKAGE;
-const MCP_SUBCOMMAND = 'mcp';
-const CLAUDE_CLI = 'claude';
-/** Windows `cmd /c` — the spawn that PowerShell's execution policy does not gate. */
-const WINDOWS_SHELL = 'cmd';
-const WINDOWS_SHELL_C = '/c';
-/**
- * Args after `npx` that launch the bridge: `@reticlehq/server mcp`. Portless — the port comes from
- * the project's `.reticle.json` at runtime, so one global entry works for every project.
- *
- * DELIBERATELY UNPINNED, and the trade is worth stating. `reticle init` pins the SDK to the CLI's
- * exact version, so on release day the app can be on the new one while npx serves a cached older
- * build — a real skew, reported from the field. Pinning this entry would remove that window.
- *
- * It would also freeze the agent's MCP server at whatever version was installed the day `init` ran,
- * for as long as that entry survives — and `reticle update` upgrades the CLI, not a global agent
- * config. Reticle's biggest measured problem is fixes not reaching people (2.4.0 reached zero users
- * before its nudge existed), and a permanent pin makes that worse for every install, to close a
- * window that lasts until the next npx cache miss.
- *
- * So it stays unpinned, and the skew is handled where it actually shows up: the contract fingerprint
- * makes a real mismatch loud on the next tool result (see version-skew), and a stale entry of our own
- * shape is now repaired on re-run rather than reported "already registered" (see mcp-clients.ts).
- */
-export function npxServerArgs() {
-    return [RETICLE_PACKAGE, MCP_SUBCOMMAND];
-}
-/** The npm scope every Reticle package shares — the marker of a registration we are entitled to fix. */
-const RETICLE_SCOPE = '@reticlehq/';
-/**
- * Is this existing registration one WE are responsible for?
- *
- * Deliberately the SCOPE and not the server package. An entry naming any `@reticlehq/*` package is
- * ours to repair — including one naming the WRONG package, which is the case this widened for:
- * `args: ["@reticlehq/core","mcp"]` was reported from the field, where `core` has no `mcp` bin, so
- * the client showed the server errored with zero tools while `init` reported it already wired and
- * left it alone on every re-run. Every `reticle_*` tool was blocked until a human edited that file.
- *
- * An entry that names no Reticle package at all — a local build, a wrapper script — is still someone
- * else's deliberate choice and is left exactly as it is.
- *
- * @param tokens every string in the entry's command + args, in any of the client shapes.
- */
-export function isReticleRegistration(tokens) {
-    return tokens.includes(NPX) && tokens.some((t) => t.includes(RETICLE_SCOPE));
-}
-/** The full `npx …` invocation — the tail after `claude mcp add … --`. */
-function serverInvocation() {
-    return [NPX, ...npxServerArgs()];
-}
-/** `claude mcp add reticle -s user -- npx @reticlehq/server mcp` — registers globally for all projects (portless). */
-export function claudeAddCommand() {
-    const tail = serverInvocation();
-    const args = [MCP_SUBCOMMAND, 'add', MCP_SERVER_NAME, '-s', 'user', '--', ...tail];
-    return { command: CLAUDE_CLI, args, display: `${CLAUDE_CLI} ${args.join(' ')}` };
-}
-/** Probe args that tell us whether an `reticle` server already exists in any scope (exit 0 = exists). */
-export function claudeExistsProbe() {
-    // NO `-s`: `claude mcp get` takes no options at all, so passing one exits 1 with "unknown option
-    // '-s'" — the probe answered "not registered" on EVERY machine, init then ran `claude mcp add`,
-    // which exits 1 with "already exists", and a re-run reported `[⚠] step failed` plus a manual
-    // command that fails the same way. A false positive from a project-scoped entry costs one skipped
-    // registration; the flag cost every re-run a failed step.
-    return { command: CLAUDE_CLI, args: [MCP_SUBCOMMAND, 'get', MCP_SERVER_NAME] };
-}
-/** Probe args for whether the `claude` CLI is installed at all. */
-export function claudeAvailableProbe() {
-    return { command: CLAUDE_CLI, args: ['--version'] };
-}
-/**
- * The Windows `cmd /c npx` registration. Printed on every Windows init, not only when the `claude`
- * CLI is missing — a successful `claude mcp add` of bare `npx` is exactly the failure that reported
- * as a clean install with zero tools.
- */
-export function mcpWindowsNote() {
-    return `On Windows, if the agent cannot start Reticle because npx is blocked ("running scripts is disabled
-on this system" — a PowerShell execution policy), register it through cmd instead, which that policy
-does not gate:
-
-  "${MCP_SERVER_NAME}": { "command": "${WINDOWS_SHELL}", "args": ${JSON.stringify([WINDOWS_SHELL_C, NPX, ...serverInvocation().slice(1)])} }`;
-}
-/** Printed when the `claude` CLI isn't available — register Reticle globally once, by hand. */
-export function mcpManual() {
-    const tail = serverInvocation().join(' ');
-    return `Register the Reticle MCP server ONCE, globally (so every project gets it):
-
-  ${CLAUDE_CLI} ${MCP_SUBCOMMAND} add ${MCP_SERVER_NAME} -s user -- ${tail}
-
-Or, for another agent, add this to its global MCP config (e.g. Cursor's ~/.cursor/mcp.json):
-
-  "${MCP_SERVER_NAME}": { "command": "${NPX}", "args": ${JSON.stringify(serverInvocation().slice(1))} }
-
-${mcpWindowsNote()}`;
-}

package/dist/init/next-patch.d.ts

@@ -1,39 +0,0 @@
-/**
- * Pure, conservative patchers for the two files a Next app needed edited BY HAND: `next.config.*`
- * (wrap the export in `withReticle`) and `app/layout.tsx` (mount `<ReticleDev />`). Same contract as
- * the Vite patcher — recognise the obvious shape, bail to `manual` on anything ambiguous, never
- * half-edit. Leaving these manual is why Next connected 0% of the time: both edits are silent when
- * skipped, and one of them is JSX.
- */
-import { type SourcePatch } from './patch-kind.js';
-/** Where the generated connect component goes, and how the mount file should import it. */
-interface ReticleDevLocation {
-    /** Project-relative path to write. */
-    path: string;
-    /** What the mount file (`app/layout.*` or `pages/_app.*`) should import. */
-    importSpecifier: string;
-}
-/**
- * Decide where the connect component lives, from the file that will mount it.
- *
- * Two things this gets wrong if hardcoded, both of which broke real apps:
- *
- * - **Pages Router routes on presence.** EVERY file under `pages/` is a route, so a component
- *   dropped there has no default export: `/reticle-dev` 500s and `next build` fails. It has to go
- *   somewhere that is not a route directory. App Router routes on FILENAME (`page`/`layout`/
- *   `route`), so an extra file beside the layout is inert and can stay there.
- * - **The extension is not cosmetic.** A `.tsx` file in a JavaScript project makes Next auto-install
- *   TypeScript on the next `next dev` — and on Next 13 that takes its require-hook down with it, so
- *   the dev server never starts. The install then looks like it broke the app, because it did.
- */
-export declare function reticleDevLocation(mountPath: string, typescript: boolean): ReticleDevLocation;
-export declare function patchNextConfig(source: string): SourcePatch;
-/**
- * Pages Router has no root layout to mount into — `app/layout.tsx` does not exist — so the connect
- * rides in `pages/_app` instead, wrapped in a fragment alongside the page. Without this, `init`
- * wrote `app/reticle-dev.tsx` into a directory the app does not have and nothing ever connected,
- * with no error to say so.
- */
-export declare function patchPagesApp(source: string, importSpecifier?: string): SourcePatch;
-export declare function patchRootLayout(source: string): SourcePatch;
-export {};

package/dist/init/next-patch.js

@@ -1,196 +0,0 @@
-/**
- * Pure, conservative patchers for the two files a Next app needed edited BY HAND: `next.config.*`
- * (wrap the export in `withReticle`) and `app/layout.tsx` (mount `<ReticleDev />`). Same contract as
- * the Vite patcher — recognise the obvious shape, bail to `manual` on anything ambiguous, never
- * half-edit. Leaving these manual is why Next connected 0% of the time: both edits are silent when
- * skipped, and one of them is JSX.
- */
-import { PatchKind } from './patch-kind.js';
-const RETICLE_NEXT_PACKAGE = '@reticlehq/next';
-const NEXT_CONFIG_IMPORT = `import { withReticle } from '${RETICLE_NEXT_PACKAGE}';`;
-const NEXT_CONFIG_REQUIRE = `const { withReticle } = require('${RETICLE_NEXT_PACKAGE}');`;
-const RETICLE_DEV_COMPONENT = 'ReticleDev';
-const RETICLE_DEV_BASENAME = 'reticle-dev';
-/** Default import specifier: the component sits beside the file importing it (App Router). */
-const RETICLE_DEV_SIBLING = `./${RETICLE_DEV_BASENAME}`;
-const reticleDevImport = (specifier) => `import { ${RETICLE_DEV_COMPONENT} } from '${specifier}';`;
-const RETICLE_DEV_IMPORT = reticleDevImport(RETICLE_DEV_SIBLING);
-/**
- * Decide where the connect component lives, from the file that will mount it.
- *
- * Two things this gets wrong if hardcoded, both of which broke real apps:
- *
- * - **Pages Router routes on presence.** EVERY file under `pages/` is a route, so a component
- *   dropped there has no default export: `/reticle-dev` 500s and `next build` fails. It has to go
- *   somewhere that is not a route directory. App Router routes on FILENAME (`page`/`layout`/
- *   `route`), so an extra file beside the layout is inert and can stay there.
- * - **The extension is not cosmetic.** A `.tsx` file in a JavaScript project makes Next auto-install
- *   TypeScript on the next `next dev` — and on Next 13 that takes its require-hook down with it, so
- *   the dev server never starts. The install then looks like it broke the app, because it did.
- */
-export function reticleDevLocation(mountPath, typescript) {
-    const ext = typescript ? '.tsx' : '.jsx';
-    const slash = mountPath.lastIndexOf('/');
-    const dir = -1 === slash ? '' : mountPath.slice(0, slash);
-    const isPagesRouter = /(^|\/)pages$/.test(dir);
-    if (!isPagesRouter) {
-        return {
-            path: `${'' === dir ? '' : `${dir}/`}${RETICLE_DEV_BASENAME}${ext}`,
-            importSpecifier: RETICLE_DEV_SIBLING,
-        };
-    }
-    // Siblings of `pages/`, so `src/pages/_app.js` → `src/components/…` and `pages/_app.js` → `components/…`.
-    const parent = dir.slice(0, Math.max(0, dir.length - 'pages'.length));
-    return {
-        path: `${parent}components/${RETICLE_DEV_BASENAME}${ext}`,
-        importSpecifier: `../components/${RETICLE_DEV_BASENAME}`,
-    };
-}
-/** The dev-guarded mount. Production strips it — `process.env.NODE_ENV` is inlined at build time. */
-const RETICLE_DEV_MOUNT = `{process.env.NODE_ENV === 'development' ? <${RETICLE_DEV_COMPONENT} /> : null}`;
-/**
- * `export default ` / `module.exports = ` at the START of a line — the head of the assignment, not
- * the whole statement. Where the exported expression ENDS is decided by `expressionEnd` below.
- *
- * These used to be `/…([\s\S]+?);?\s*$/`, which reads as "the expression, lazily". It is not: with
- * no `m` flag the `$` is end-of-FILE and the trailing `;?\s*` is satisfiable only there, so the
- * capture always ran to the last non-blank character of the file. Every config whose export was not
- * the final statement got everything after it swallowed into the wrap. On a config exporting
- * conditionally that produced an unbalanced paren — a syntax error, so `next dev` exited 1 while
- * `init` reported the step as ✓ and the only symptom was "dev server never served".
- */
-const ESM_DEFAULT_HEAD = /^[ \t]*export[ \t]+default[ \t]+/gm;
-const CJS_EXPORT_HEAD = /^[ \t]*module\.exports[ \t]*=[ \t]*/gm;
-/** The opening `<body ...>` tag, whose first child is where the mount goes. */
-const BODY_OPEN_TAG = /<body(\s[^>]*)?>/g;
-const NO_EXPORT_REASON = "couldn't find an `export default` or `module.exports` to wrap";
-const NO_BODY_REASON = "couldn't find a single <body> tag to mount <ReticleDev /> inside";
-/** Bracket pairs that keep an expression open. A `;` at depth 0 is what ends it. */
-const OPENERS = '([{';
-const CLOSERS = ')]}';
-const LINE_COMMENT = '//';
-const BLOCK_COMMENT_OPEN = '/*';
-const BLOCK_COMMENT_CLOSE = '*/';
-const QUOTES = '\'"`';
-/**
- * Index just past the exported expression that starts at `from` — the `;` that closes it, or end of
- * file. Tracks bracket depth so a multi-line object or a nested call ends in the right place, and
- * skips strings and comments so a `;` or a brace inside one cannot end it early.
- *
- * Deliberately a scanner and not a parser: `next.config.*` is arbitrary JS and this file's contract
- * is to recognise the obvious shape or bail. It only has to be right about where ONE expression
- * stops, and wrong is caught by the caller bailing to manual, never by a half-edit.
- */
-function expressionEnd(source, from) {
-    let depth = 0;
-    for (let i = from; i < source.length; i++) {
-        const ch = source[i] ?? '';
-        const pair = source.slice(i, i + 2);
-        if (pair === LINE_COMMENT) {
-            const nl = source.indexOf('\n', i);
-            if (-1 === nl)
-                return source.length;
-            i = nl;
-            continue;
-        }
-        if (pair === BLOCK_COMMENT_OPEN) {
-            const close = source.indexOf(BLOCK_COMMENT_CLOSE, i + 2);
-            i = -1 === close ? source.length : close + 1;
-            continue;
-        }
-        if (QUOTES.includes(ch)) {
-            for (i++; i < source.length; i++) {
-                if ('\\' === source[i])
-                    i++;
-                else if (source[i] === ch)
-                    break;
-            }
-            continue;
-        }
-        if (OPENERS.includes(ch))
-            depth++;
-        else if (CLOSERS.includes(ch)) {
-            // A closer at depth 0 belongs to an enclosing block, so the expression ended before it.
-            if (0 === depth)
-                return i;
-            depth--;
-        }
-        else if (';' === ch && 0 === depth)
-            return i;
-    }
-    return source.length;
-}
-/** Every top-level export assignment in the file, in source order. */
-function exportSites(source, head) {
-    const sites = [];
-    for (const match of source.matchAll(head)) {
-        if (match.index === undefined)
-            continue;
-        const start = match.index + match[0].length;
-        sites.push({ start, end: expressionEnd(source, start) });
-    }
-    return sites;
-}
-/**
- * Wrap every listed expression in `withReticle(...)`, leaving every other byte of the file alone.
- *
- * All of them, not just the first: a config can export CONDITIONALLY — Sentry-wrapped in one branch,
- * plain in the other — and which branch runs is an environment variable's business, not ours.
- * Wrapping each assignment is correct whichever one executes, and it is what turns that shape from a
- * manual step (an app that boots and never connects) into a working install.
- *
- * Applied back-to-front so each splice leaves the earlier offsets valid.
- */
-function wrapAll(source, sites) {
-    let out = source;
-    for (const site of [...sites].sort((a, b) => b.start - a.start)) {
-        out = `${out.slice(0, site.start)}withReticle(${out.slice(site.start, site.end)})${out.slice(site.end)}`;
-    }
-    return out;
-}
-export function patchNextConfig(source) {
-    if (source.includes(RETICLE_NEXT_PACKAGE))
-        return { kind: PatchKind.ALREADY };
-    const esm = exportSites(source, ESM_DEFAULT_HEAD);
-    if (esm.length > 0) {
-        return { kind: PatchKind.APPLY, code: `${NEXT_CONFIG_IMPORT}\n${wrapAll(source, esm)}` };
-    }
-    const cjs = exportSites(source, CJS_EXPORT_HEAD);
-    if (cjs.length > 0) {
-        return { kind: PatchKind.APPLY, code: `${NEXT_CONFIG_REQUIRE}\n${wrapAll(source, cjs)}` };
-    }
-    return { kind: PatchKind.MANUAL, reason: NO_EXPORT_REASON };
-}
-/** `<Component {...pageProps} />` — the one element every `pages/_app` renders. */
-const PAGES_APP_COMPONENT = /<Component\b[^>]*\/>/g;
-const NO_PAGES_COMPONENT_REASON = "couldn't find a single <Component {...pageProps} /> to wrap in pages/_app";
-/**
- * Pages Router has no root layout to mount into — `app/layout.tsx` does not exist — so the connect
- * rides in `pages/_app` instead, wrapped in a fragment alongside the page. Without this, `init`
- * wrote `app/reticle-dev.tsx` into a directory the app does not have and nothing ever connected,
- * with no error to say so.
- */
-export function patchPagesApp(source, importSpecifier = RETICLE_DEV_SIBLING) {
-    if (source.includes(RETICLE_DEV_COMPONENT))
-        return { kind: PatchKind.ALREADY };
-    const matches = [...source.matchAll(PAGES_APP_COMPONENT)];
-    const match = 1 === matches.length ? matches[0] : undefined;
-    if (match?.index === undefined)
-        return { kind: PatchKind.MANUAL, reason: NO_PAGES_COMPONENT_REASON };
-    const wrapped = `<>${RETICLE_DEV_MOUNT}${match[0]}</>`;
-    const code = source.slice(0, match.index) + wrapped + source.slice(match.index + match[0].length);
-    return { kind: PatchKind.APPLY, code: `${reticleDevImport(importSpecifier)}\n${code}` };
-}
-export function patchRootLayout(source) {
-    if (source.includes(RETICLE_DEV_COMPONENT))
-        return { kind: PatchKind.ALREADY };
-    const tags = [...source.matchAll(BODY_OPEN_TAG)];
-    // Exactly one <body> or we cannot tell which one actually renders — and mounting into the wrong
-    // one is the same silent no-connect as not mounting at all.
-    const tag = 1 === tags.length ? tags[0] : undefined;
-    if (tag?.index === undefined)
-        return { kind: PatchKind.MANUAL, reason: NO_BODY_REASON };
-    const insertAt = tag.index + tag[0].length;
-    const mounted = `${source.slice(0, insertAt)}${RETICLE_DEV_MOUNT}${source.slice(insertAt)}`;
-    return { kind: PatchKind.APPLY, code: `${RETICLE_DEV_IMPORT}\n${mounted}` };
-}

package/dist/init/node-io.d.ts

@@ -1,7 +0,0 @@
-/**
- * The real (Node filesystem) implementation of `InitIo`. Kept separate from the pure runner so
- * `runInit` stays testable with an in-memory IO. Prints to stdout — `init` is a one-shot CLI
- * command, not the MCP stdio transport.
- */
-import type { InitIo } from './run.js';
-export declare function buildNodeIo(cwd: string): InitIo;

package/dist/init/node-io.js

@@ -1,117 +0,0 @@
-/**
- * The real (Node filesystem) implementation of `InitIo`. Kept separate from the pure runner so
- * `runInit` stays testable with an in-memory IO. Prints to stdout — `init` is a one-shot CLI
- * command, not the MCP stdio transport.
- */
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, accessSync, constants, } from 'node:fs';
-import { NodePlatform } from '../platform.js';
-import { join, dirname, isAbsolute } from 'node:path';
-import { homedir } from 'node:os';
-import { spawnSync } from 'node:child_process';
-import { windowsShellArg } from './windows-quote.js';
-/**
- * `shell: true` ONLY where it earns its keep.
- *
- * It exists so package-manager shims (`pnpm.cmd`, `npx.cmd`) resolve on Windows. On POSIX it buys
- * nothing and costs correctness: under a shell, arguments are re-parsed, so a path containing a
- * space — `/Users/ada/My Projects/app` — silently becomes two arguments and registration fails with
- * no error anyone can read.
- */
-function shellOpt() {
-    return NodePlatform.WINDOWS === process.platform ? { shell: true } : {};
-}
-/**
- * Under a shell, quote what the shell would otherwise split or interpret. Windows only, where
- * `shell: true` is required (see shellOpt). The rule itself lives in windows-quote.ts as a pure
- * function so it can be tested on every platform — keeping it inside this branch is why it was
- * wrong for as long as it was.
- */
-function shellSafe(args) {
-    if (process.platform !== NodePlatform.WINDOWS)
-        return [...args];
-    return args.map(windowsShellArg);
-}
-export function buildNodeIo(cwd) {
-    // Project-relative by default; absolute paths (e.g. ~/.cursor/mcp.json) pass through unchanged.
-    const abs = (rel) => (isAbsolute(rel) ? rel : join(cwd, rel));
-    return {
-        readFile(rel) {
-            const path = abs(rel);
-            if (!existsSync(path))
-                return null;
-            return readFileSync(path, 'utf8');
-        },
-        writeFile(rel, content) {
-            const path = abs(rel);
-            mkdirSync(dirname(path), { recursive: true });
-            writeFileSync(path, content, 'utf8');
-        },
-        exists(rel) {
-            return existsSync(abs(rel));
-        },
-        homeDir() {
-            return homedir();
-        },
-        cwd() {
-            return cwd;
-        },
-        rootFiles() {
-            return readdirSync(cwd).filter((name) => {
-                try {
-                    return statSync(join(cwd, name)).isFile();
-                }
-                catch {
-                    return false;
-                }
-            });
-        },
-        listDirs(rel) {
-            const path = abs(rel);
-            if (!existsSync(path))
-                return [];
-            try {
-                return readdirSync(path).filter((name) => statSync(join(path, name)).isDirectory());
-            }
-            catch {
-                return [];
-            }
-        },
-        listFiles(rel) {
-            const path = abs(rel);
-            if (!existsSync(path))
-                return [];
-            try {
-                return readdirSync(path).filter((name) => !statSync(join(path, name)).isDirectory());
-            }
-            catch {
-                return [];
-            }
-        },
-        scoped(rel) {
-            return buildNodeIo(abs(rel));
-        },
-        exec(command, args) {
-            // Inherit stdio so the install's own progress is visible to the user.
-            const result = spawnSync(command, shellSafe(args), { cwd, stdio: 'inherit', ...shellOpt() });
-            return 0 === result.status;
-        },
-        /** One access check, rather than discovering it as an EACCES stack four phases later. */
-        canWrite() {
-            try {
-                accessSync(cwd, constants.W_OK);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        },
-        probe(command, args) {
-            // Quiet yes/no check (CLI availability, existing registration). Never throws.
-            const result = spawnSync(command, shellSafe(args), { cwd, stdio: 'ignore', ...shellOpt() });
-            return 0 === result.status;
-        },
-        print(line) {
-            process.stdout.write(`${line}\n`);
-        },
-    };
-}

package/dist/init/non-js-project.d.ts

@@ -1,27 +0,0 @@
-/**
- * Telling a Python (or Ruby, or Go, or PHP) developer why Reticle cannot wire their app.
- *
- * `reticle init` answered "No package.json found here, and no app directory beneath it either",
- * which reads as *you are in the wrong directory* — so an agent on a Streamlit app went looking for
- * a directory that does not exist, then went looking for a standalone browser bundle to inject by
- * hand, and only worked out the real answer several steps later.
- *
- * The real answer is not about directories at all: Reticle's SDK has to be imported by the app's own
- * JS build, and a server-rendered Python app has no JS build to import it from. That is a property
- * of the project, it is knowable from one look at the filesystem, and saying it plainly costs the
- * reader nothing while the directory message costs them the whole investigation.
- *
- * Deliberately a hint, not a refusal: a Django or Rails app with a `frontend/` package.json is a
- * perfectly ordinary Reticle install, and this only ever speaks when there is no package.json to be
- * found anywhere.
- */
-/** The ecosystem this directory looks like, or undefined when nothing says. */
-export declare function detectNonJsEcosystem(exists: (file: string) => boolean): string | undefined;
-/**
- * What `init` should say when there is no package.json.
- *
- * Two genuinely different situations behind one old sentence: a JS developer standing in the wrong
- * directory, and a developer whose project is not JavaScript at all. The first needs a path; the
- * second needs to know that no path exists and why.
- */
-export declare function noPackageJsonMessage(exists: (file: string) => boolean): string;

package/dist/init/non-js-project.js

@@ -1,84 +0,0 @@
-/**
- * Telling a Python (or Ruby, or Go, or PHP) developer why Reticle cannot wire their app.
- *
- * `reticle init` answered "No package.json found here, and no app directory beneath it either",
- * which reads as *you are in the wrong directory* — so an agent on a Streamlit app went looking for
- * a directory that does not exist, then went looking for a standalone browser bundle to inject by
- * hand, and only worked out the real answer several steps later.
- *
- * The real answer is not about directories at all: Reticle's SDK has to be imported by the app's own
- * JS build, and a server-rendered Python app has no JS build to import it from. That is a property
- * of the project, it is knowable from one look at the filesystem, and saying it plainly costs the
- * reader nothing while the directory message costs them the whole investigation.
- *
- * Deliberately a hint, not a refusal: a Django or Rails app with a `frontend/` package.json is a
- * perfectly ordinary Reticle install, and this only ever speaks when there is no package.json to be
- * found anywhere.
- */
-/** Marker files that identify an ecosystem, and what to call it. */
-const ECOSYSTEM_MARKERS = [
-    ['requirements.txt', 'Python'],
-    ['pyproject.toml', 'Python'],
-    ['Pipfile', 'Python'],
-    ['setup.py', 'Python'],
-    ['manage.py', 'Python (Django)'],
-    ['Gemfile', 'Ruby'],
-    ['go.mod', 'Go'],
-    ['composer.json', 'PHP'],
-    ['Cargo.toml', 'Rust'],
-    ['pom.xml', 'Java'],
-    ['build.gradle', 'Java'],
-    ['mix.exs', 'Elixir'],
-    // Not like the others. Every ecosystem above can grow a JS front end that Reticle instruments
-    // perfectly well, so their message ends with a lead. Flutter web paints into a canvas, and there
-    // is no DOM behind it at any path, so the honest answer is a named refusal.
-    ['pubspec.yaml', 'Flutter'],
-];
-/** The one ecosystem where no directory, front end or flag could ever help. */
-const FLUTTER = 'Flutter';
-/** The ecosystem this directory looks like, or undefined when nothing says. */
-export function detectNonJsEcosystem(exists) {
-    for (const [marker, name] of ECOSYSTEM_MARKERS) {
-        if (exists(marker))
-            return name;
-    }
-    return undefined;
-}
-/**
- * What `init` should say when there is no package.json.
- *
- * Two genuinely different situations behind one old sentence: a JS developer standing in the wrong
- * directory, and a developer whose project is not JavaScript at all. The first needs a path; the
- * second needs to know that no path exists and why.
- */
-export function noPackageJsonMessage(exists) {
-    const ecosystem = detectNonJsEcosystem(exists);
-    if (ecosystem === undefined) {
-        return ('No package.json found here, and no app directory beneath it either. Run `reticle init` from ' +
-            "your app's directory, or from a repo root that contains it.");
-    }
-    if (ecosystem === FLUTTER) {
-        // An agent on a Flutter workspace asked us to "support Flutter, or clearly identify it as
-        // unsupported during init". The second is the truthful one, and saying it by name in one line
-        // is the difference between an agent that stops and an agent that spends an hour looking for
-        // the package.json we told it was missing.
-        return ('This is a Flutter project. Reticle cannot instrument it, and no directory or flag will ' +
-            'change that: Reticle reads the DOM of a running page, and Flutter web paints its entire UI ' +
-            'into a single canvas element with no DOM behind it. Nothing here is missing or misconfigured. ' +
-            'If this repo also contains an ordinary web app with its own package.json, run `reticle init` ' +
-            'inside that directory instead.');
-    }
-    return (`This looks like a ${ecosystem} project, and there is no package.json here or in any app ` +
-        'directory beneath it. That is not a blocker: Reticle needs its SDK loaded by the page, not ' +
-        'built by npm, and a page with no build step can load it from a URL. ' +
-        // The old message ended at "there is no directory you could run this from that would change
-        // that", which read as a refusal and was acted on as one — agents went looking for a bundler,
-        // or for a standalone build to inject by hand, or gave up and used a different tool. The
-        // capability was there the whole time; only the sentence was missing. Proven end to end on a
-        // page served by `python3 -m http.server` before this line was written.
-        'Add the script-tag snippet below to a template you only serve in development, then reload the ' +
-        'page. ' +
-        'If this project ALSO has a JS front end (a `frontend/`, `client/` or `assets/` directory with ' +
-        'its own package.json), running `reticle init` there instead gives you source mapping and ' +
-        'framework state as well: point at it with `--app <dir>`.');
-}

package/dist/init/patch-kind.d.ts

@@ -1,20 +0,0 @@
-/**
- * The outcome vocabulary shared by every conservative source patcher in `init` (Vite config, Next
- * config, Next root layout). One enum so a new patcher cannot invent a fourth status the reporter
- * has no symbol for.
- */
-export declare const PatchKind: {
-    readonly APPLY: "apply";
-    readonly ALREADY: "already";
-    readonly MANUAL: "manual";
-};
-export type PatchKind = (typeof PatchKind)[keyof typeof PatchKind];
-export type SourcePatch = {
-    kind: typeof PatchKind.APPLY;
-    code: string;
-} | {
-    kind: typeof PatchKind.ALREADY;
-} | {
-    kind: typeof PatchKind.MANUAL;
-    reason: string;
-};

package/dist/init/patch-kind.js

@@ -1,10 +0,0 @@
-/**
- * The outcome vocabulary shared by every conservative source patcher in `init` (Vite config, Next
- * config, Next root layout). One enum so a new patcher cannot invent a fourth status the reporter
- * has no symbol for.
- */
-export const PatchKind = {
-    APPLY: 'apply',
-    ALREADY: 'already',
-    MANUAL: 'manual',
-};