@nwire/cli 0.9.1 → 0.10.0

package/dist/commands/lint.d.ts

@@ -1,6 +1,11 @@
 /**
- * `nwire lint` — passthrough to `oxlint` wrapped in a listr2 task.
- * Honors the consumer project's oxlint config.
+ * `nwire lint` — run the consumer's lint. Picks the first available
+ * source in order:
+ *
+ *   1. `scripts.lint` (and `scripts.lint:fix` for `--fix`)
+ *   2. Any installed linter — `oxlint`, then `eslint`.
+ *
+ * Extra positional args / flags pass through.
  */
 export declare const lintCommand: import("citty").CommandDef<{
     fix: {
@@ -9,4 +14,3 @@ export declare const lintCommand: import("citty").CommandDef<{
         default: false;
     };
 }>;
-//# sourceMappingURL=lint.d.ts.map

package/dist/commands/lint.js

@@ -1,13 +1,19 @@
 /**
- * `nwire lint` — passthrough to `oxlint` wrapped in a listr2 task.
- * Honors the consumer project's oxlint config.
+ * `nwire lint` — run the consumer's lint. Picks the first available
+ * source in order:
+ *
+ *   1. `scripts.lint` (and `scripts.lint:fix` for `--fix`)
+ *   2. Any installed linter — `oxlint`, then `eslint`.
+ *
+ * Extra positional args / flags pass through.
  */
 import { defineCommand } from "citty";
-import { runTaskList } from "../lib/run-task.js";
+import { palette } from "../lib/colors.js";
+import { runScriptStrategy } from "../lib/script-runner.js";
 export const lintCommand = defineCommand({
     meta: {
         name: "lint",
-        description: "Lint the project with oxlint",
+        description: "Lint the project (consumer-defined or installed linter)",
     },
     args: {
         fix: {
@@ -17,16 +23,31 @@ export const lintCommand = defineCommand({
         },
     },
     async run({ args, rawArgs }) {
+        const cwd = process.cwd();
         const passthrough = rawArgs.filter((a) => a !== "--fix");
-        const oxlintArgs = args.fix ? ["--fix", ...passthrough] : passthrough;
-        const code = await runTaskList([
-            {
-                title: args.fix ? "oxlint --fix" : "oxlint",
-                command: "pnpm",
-                args: ["exec", "oxlint", ...oxlintArgs],
-            },
-        ]);
+        const fixArgs = args.fix ? ["--fix"] : [];
+        const { code, ran } = await runScriptStrategy(cwd, {
+            operationName: "lint",
+            consumerScript: args.fix ? "lint:fix" : "lint",
+            fallback: [
+                {
+                    title: args.fix ? "oxlint --fix" : "oxlint",
+                    bin: "oxlint",
+                    args: [...fixArgs, ...passthrough],
+                },
+                {
+                    title: args.fix ? "eslint --fix" : "eslint",
+                    bin: "eslint",
+                    args: [...fixArgs, ".", ...passthrough],
+                },
+            ],
+        });
+        if (!ran) {
+            // eslint-disable-next-line no-console
+            console.error(palette.err("nwire lint:") +
+                " no `lint` script and no installed linter (oxlint or eslint).");
+            process.exit(1);
+        }
         process.exit(code);
     },
 });
-//# sourceMappingURL=lint.js.map

package/dist/commands/logs.d.ts

@@ -18,4 +18,3 @@ export declare const logsCommand: import("citty").CommandDef<{
         default: false;
     };
 }>;
-//# sourceMappingURL=logs.d.ts.map

package/dist/commands/logs.js

@@ -123,4 +123,3 @@ export const logsCommand = defineCommand({
         process.on("SIGTERM", stop);
     },
 });
-//# sourceMappingURL=logs.js.map

package/dist/commands/ls.d.ts

@@ -1,5 +1,5 @@
 /**
  * `nwire ls` — lists every discovered wire and every action.
+ * Runs an incremental scan first so the manifest is fresh.
  */
 export declare const lsCommand: import("citty").CommandDef<import("citty").ArgsDef>;
-//# sourceMappingURL=ls.d.ts.map

package/dist/commands/ls.js

@@ -1,11 +1,13 @@
 /**
  * `nwire ls` — lists every discovered wire and every action.
+ * Runs an incremental scan first so the manifest is fresh.
  */
 import { defineCommand } from "citty";
 import { resolve, dirname } from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { palette } from "../lib/colors.js";
+import { ensureScanFresh } from "../lib/ensure-scan.js";
 import { viteNode } from "../lib/vite-node.js";
 const here = dirname(fileURLToPath(import.meta.url));
 export const lsCommand = defineCommand({
@@ -14,6 +16,7 @@ export const lsCommand = defineCommand({
         description: "List discovered wires + actions",
     },
     async run({ rawArgs }) {
+        ensureScanFresh(process.cwd(), { quiet: true });
         const builderPath = resolve(here, "..", "ls-runner.js");
         if (!existsSync(builderPath)) {
             // eslint-disable-next-line no-console
@@ -23,4 +26,3 @@ export const lsCommand = defineCommand({
         process.exit(viteNode(builderPath, rawArgs));
     },
 });
-//# sourceMappingURL=ls.js.map

package/dist/commands/mcp.d.ts

@@ -2,4 +2,3 @@
  * `nwire mcp` — start the MCP server on stdio for Claude / Cursor clients.
  */
 export declare const mcpCommand: import("citty").CommandDef<import("citty").ArgsDef>;
-//# sourceMappingURL=mcp.d.ts.map

package/dist/commands/mcp.js

@@ -3,6 +3,7 @@
  */
 import { defineCommand } from "citty";
 import { serveMcp } from "@nwire/mcp";
+import { cliVersion } from "../lib/version.js";
 export const mcpCommand = defineCommand({
     meta: {
         name: "mcp",
@@ -11,8 +12,7 @@ export const mcpCommand = defineCommand({
     async run() {
         await serveMcp({
             serverName: "nwire",
-            serverVersion: "0.9.0",
+            serverVersion: cliVersion(),
         });
     },
 });
-//# sourceMappingURL=mcp.js.map

package/dist/commands/please.d.ts

@@ -10,4 +10,3 @@ export declare const pleaseCommand: import("citty").CommandDef<{
         description: string;
     };
 }>;
-//# sourceMappingURL=please.d.ts.map

package/dist/commands/please.js

@@ -43,4 +43,3 @@ export const pleaseCommand = defineCommand({
         process.exit(viteNode(pleasePath, rawArgs));
     },
 });
-//# sourceMappingURL=please.js.map

package/dist/commands/ps.d.ts

@@ -3,4 +3,3 @@
  * record under `.nwire/processes/*.json` and renders an ink table.
  */
 export declare const psCommand: import("citty").CommandDef<import("citty").ArgsDef>;
-//# sourceMappingURL=ps.d.ts.map

package/dist/commands/ps.js

@@ -18,4 +18,3 @@ export const psCommand = defineCommand({
         await waitUntilExit();
     },
 });
-//# sourceMappingURL=ps.js.map

package/dist/commands/replay.d.ts

@@ -42,4 +42,3 @@ export declare const replayCommand: import("citty").CommandDef<{
     };
 }>;
 export {};
-//# sourceMappingURL=replay.d.ts.map

package/dist/commands/replay.js

@@ -155,4 +155,3 @@ export const replayCommand = defineCommand({
         }
     },
 });
-//# sourceMappingURL=replay.js.map

package/dist/commands/run.d.ts

@@ -16,4 +16,3 @@ export declare const runCommand: import("citty").CommandDef<{
         description: string;
     };
 }>;
-//# sourceMappingURL=run.d.ts.map

package/dist/commands/run.js

@@ -119,4 +119,3 @@ export const runCommand = defineCommand({
         process.exit(exitCode);
     },
 });
-//# sourceMappingURL=run.js.map

package/dist/commands/studio.d.ts

@@ -6,4 +6,3 @@
  * right `.nwire/` and `apps/topologies/`.
  */
 export declare const studioCommand: import("citty").CommandDef<import("citty").ArgsDef>;
-//# sourceMappingURL=studio.d.ts.map

package/dist/commands/studio.js

@@ -11,18 +11,29 @@ import { resolve, dirname } from "node:path";
 import { existsSync } from "node:fs";
 import { palette } from "../lib/colors.js";
 import { spawnInteractive } from "../lib/exec.js";
-const localRequire = createRequire(import.meta.url);
 export const studioCommand = defineCommand({
     meta: {
         name: "studio",
         description: "Boot Nwire Studio (Vue + Vite UI)",
     },
     async run({ rawArgs }) {
+        // Try resolving @nwire/studio from the consumer's cwd first (so a
+        // dev-deps install in their project works), then from the CLI's own
+        // location (covers the framework workspace + `pnpm dlx` flows).
         let studioDir;
-        try {
-            studioDir = dirname(localRequire.resolve("@nwire/studio/package.json"));
-        }
-        catch {
+        const tryResolveFrom = (basePath) => {
+            try {
+                const req = createRequire(basePath);
+                return dirname(req.resolve("@nwire/studio/package.json"));
+            }
+            catch {
+                return undefined;
+            }
+        };
+        studioDir =
+            tryResolveFrom(resolve(process.cwd(), "package.json")) ??
+                tryResolveFrom(import.meta.url);
+        if (!studioDir) {
             // eslint-disable-next-line no-console
             console.error(palette.err("nwire studio:") +
                 " @nwire/studio not installed. `pnpm add -D @nwire/studio` first.");
@@ -49,4 +60,3 @@ export const studioCommand = defineCommand({
         process.exit(await done);
     },
 });
-//# sourceMappingURL=studio.js.map

package/dist/commands/test.d.ts

@@ -23,4 +23,3 @@ export declare const testCommand: import("citty").CommandDef<{
         default: false;
     };
 }>;
-//# sourceMappingURL=test.d.ts.map

package/dist/commands/test.js

@@ -143,4 +143,3 @@ export const testCommand = defineCommand({
         process.exit(await runTaskList(tasks));
     },
 });
-//# sourceMappingURL=test.js.map

package/dist/commands/trace.d.ts

@@ -37,4 +37,3 @@ export declare const traceCommand: import("citty").CommandDef<{
     };
 }>;
 export {};
-//# sourceMappingURL=trace.d.ts.map

package/dist/commands/trace.js

@@ -195,4 +195,3 @@ function sleep(ms, signal) {
         }, { once: true });
     });
 }
-//# sourceMappingURL=trace.js.map

package/dist/commands/watch.d.ts

@@ -30,4 +30,3 @@ export declare const watchCommand: import("citty").CommandDef<{
     };
 }>;
 export {};
-//# sourceMappingURL=watch.d.ts.map

package/dist/commands/watch.js

@@ -152,4 +152,3 @@ function sleep(ms, signal) {
         }, { once: true });
     });
 }
-//# sourceMappingURL=watch.js.map

package/dist/index.d.ts

@@ -8,4 +8,3 @@
  *   export default defineConfig({ appsEntry: "./src/app.ts" })
  */
 export { defineConfig, type NwireConfig } from "./load-config.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -8,4 +8,3 @@
  *   export default defineConfig({ appsEntry: "./src/app.ts" })
  */
 export { defineConfig } from "./load-config.js";
-//# sourceMappingURL=index.js.map

package/dist/lib/colors.d.ts

@@ -16,4 +16,3 @@ export declare const palette: {
     bold: import("picocolors/types").Formatter;
     hint: import("picocolors/types").Formatter;
 };
-//# sourceMappingURL=colors.d.ts.map

package/dist/lib/colors.js

@@ -15,4 +15,3 @@ export const palette = {
     bold: pc.bold,
     hint: pc.gray,
 };
-//# sourceMappingURL=colors.js.map

package/dist/lib/dev-entry.d.ts

@@ -36,4 +36,3 @@ export type DevEntry = {
 export declare function resolveDevEntry(cwd: string): DevEntry | undefined;
 /** Same fallback list rendered for the "no dev entry found" error message. */
 export declare function devEntryCandidates(): readonly string[];
-//# sourceMappingURL=dev-entry.d.ts.map

package/dist/lib/dev-entry.js

@@ -99,4 +99,3 @@ function relPath(cwd, abs) {
     const rel = relative(cwd, abs);
     return rel === "" ? abs : rel;
 }
-//# sourceMappingURL=dev-entry.js.map

package/dist/lib/ensure-scan.d.ts

@@ -0,0 +1,28 @@
+/**
+ * `ensureScanFresh` — guarantee `.nwire/manifest.json` (and the rest of
+ * the per-kind JSON files) reflect the current source tree. Called by
+ * every CLI command that reads the scan cache.
+ *
+ * Cheap path: compute fingerprint, compare to saved; if match, return.
+ * Expensive path: spawn the cache-runner under vite-node to rebuild,
+ * then save the new fingerprint. The expensive path runs at most once
+ * per source change.
+ */
+export interface EnsureScanOptions {
+    /**
+     * When `true`, run the cache builder even if the fingerprint matches.
+     * Useful for `nwire cache` itself.
+     */
+    readonly force?: boolean;
+    /**
+     * When `true`, do not print "scan refreshed" messages. Default `false`.
+     */
+    readonly quiet?: boolean;
+}
+export interface EnsureScanResult {
+    /** Whether the cache was rebuilt during this call. */
+    readonly rebuilt: boolean;
+    /** The fingerprint that's now saved on disk. */
+    readonly fingerprint: string;
+}
+export declare function ensureScanFresh(cwd?: string, opts?: EnsureScanOptions): EnsureScanResult;

package/dist/lib/ensure-scan.js

@@ -0,0 +1,41 @@
+/**
+ * `ensureScanFresh` — guarantee `.nwire/manifest.json` (and the rest of
+ * the per-kind JSON files) reflect the current source tree. Called by
+ * every CLI command that reads the scan cache.
+ *
+ * Cheap path: compute fingerprint, compare to saved; if match, return.
+ * Expensive path: spawn the cache-runner under vite-node to rebuild,
+ * then save the new fingerprint. The expensive path runs at most once
+ * per source change.
+ */
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { palette } from "./colors.js";
+import { execSync } from "./exec.js";
+import { fingerprint, isFresh, writeFingerprint } from "./scan-cache.js";
+const here = dirname(fileURLToPath(import.meta.url));
+export function ensureScanFresh(cwd = process.cwd(), opts = {}) {
+    const fp = fingerprint(cwd);
+    if (!opts.force && isFresh(cwd, fp)) {
+        return { rebuilt: false, fingerprint: fp };
+    }
+    const builderPath = resolve(here, "..", "cache-runner.js");
+    if (!existsSync(builderPath)) {
+        // Builder is missing from dist (dev-mode oddity). Skip — commands
+        // that need the cache will surface their own "no manifest" error.
+        return { rebuilt: false, fingerprint: fp };
+    }
+    if (!opts.quiet) {
+        // eslint-disable-next-line no-console
+        console.error(palette.dim("scanning project…"));
+    }
+    const code = execSync("pnpm", ["exec", "vite-node", builderPath]);
+    if (code !== 0) {
+        // Cache build failed; keep whatever's on disk. Don't update the
+        // fingerprint, so the next call retries.
+        return { rebuilt: false, fingerprint: fp };
+    }
+    writeFingerprint(cwd, fp);
+    return { rebuilt: true, fingerprint: fp };
+}

package/dist/lib/exec.d.ts

@@ -34,4 +34,3 @@ export declare function spawnInteractive(cmd: string, args: readonly string[], o
     child: ChildProcess;
     done: Promise<number>;
 };
-//# sourceMappingURL=exec.d.ts.map

package/dist/lib/exec.js

@@ -73,4 +73,3 @@ export function spawnInteractive(cmd, args, opts = {}) {
     });
     return { child, done };
 }
-//# sourceMappingURL=exec.js.map

package/dist/lib/layout.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Canonical layout discovery for the CLI. Every command that needs to
+ * know what shape the consumer's project is in reads this module —
+ * one source of truth for "what is a wire and where is it."
+ *
+ * Discovery proceeds in priority order. The first match wins:
+ *
+ *   1. `nwire.config.{ts,js,mts,mjs}` declares an apps entry explicitly.
+ *   2. `package.json#nwire.wires` lists wires explicitly.
+ *   3. `apps/<name>/{run,main}.ts` — multi-wire layout. Each subdir is
+ *      a wire named after its directory.
+ *   4. `app/{run,main}.ts` — single-wire layout. One wire named after
+ *      the package (or "app" if the package is unnamed).
+ *   5. `src/{main,index}.ts` and `./{main,index}.ts` — small-project
+ *      conventions; one wire named after the package.
+ *
+ * Returns an empty `wires` list when nothing matches — callers print a
+ * helpful message rather than crashing on undefined.
+ */
+export interface Wire {
+    /** Display name. Used by `nwire build <wire>`, `nwire ls`, status output. */
+    readonly name: string;
+    /** Absolute path to the entry file (.ts / .mts / .js / .mjs). */
+    readonly entry: string;
+}
+export interface ProjectLayout {
+    readonly cwd: string;
+    readonly packageName: string;
+    readonly wires: readonly Wire[];
+    /** Path to nwire.config.* if one was found. */
+    readonly configPath?: string;
+    /** True when the project declared wires explicitly (config or package.json). */
+    readonly explicit: boolean;
+}
+export declare function detectLayout(cwd?: string): ProjectLayout;
+/**
+ * Resolve a named wire to its entry file. `nwire build foo` calls this
+ * with `foo`; we return the entry path or `undefined` if unknown.
+ */
+export declare function resolveWire(layout: ProjectLayout, name: string): string | undefined;

package/dist/lib/layout.js

@@ -0,0 +1,128 @@
+/**
+ * Canonical layout discovery for the CLI. Every command that needs to
+ * know what shape the consumer's project is in reads this module —
+ * one source of truth for "what is a wire and where is it."
+ *
+ * Discovery proceeds in priority order. The first match wins:
+ *
+ *   1. `nwire.config.{ts,js,mts,mjs}` declares an apps entry explicitly.
+ *   2. `package.json#nwire.wires` lists wires explicitly.
+ *   3. `apps/<name>/{run,main}.ts` — multi-wire layout. Each subdir is
+ *      a wire named after its directory.
+ *   4. `app/{run,main}.ts` — single-wire layout. One wire named after
+ *      the package (or "app" if the package is unnamed).
+ *   5. `src/{main,index}.ts` and `./{main,index}.ts` — small-project
+ *      conventions; one wire named after the package.
+ *
+ * Returns an empty `wires` list when nothing matches — callers print a
+ * helpful message rather than crashing on undefined.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+const CONFIG_NAMES = ["nwire.config.ts", "nwire.config.mts", "nwire.config.js", "nwire.config.mjs"];
+const ENTRY_NAMES = ["run.ts", "main.ts", "index.ts", "app.ts", "run.mts", "main.mts"];
+function readPackage(cwd) {
+    const pkgPath = resolve(cwd, "package.json");
+    if (!existsSync(pkgPath))
+        return {};
+    try {
+        return JSON.parse(readFileSync(pkgPath, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function firstExistingEntry(dir) {
+    for (const name of ENTRY_NAMES) {
+        const p = resolve(dir, name);
+        if (existsSync(p))
+            return p;
+    }
+    return undefined;
+}
+function findAppsLayout(cwd) {
+    const appsDir = resolve(cwd, "apps");
+    if (!existsSync(appsDir))
+        return [];
+    const out = [];
+    for (const entry of readdirSync(appsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const wireDir = resolve(appsDir, entry.name);
+        const wireEntry = firstExistingEntry(wireDir);
+        if (wireEntry)
+            out.push({ name: entry.name, entry: wireEntry });
+        // `apps/foo/run.<variant>.ts` — siblings of run.ts (e.g. run.worker.ts)
+        // become distinct wires named `foo.<variant>`. Preserves the multi-wire
+        // per-app convention without forcing every project into it.
+        for (const f of readdirSync(wireDir)) {
+            if (!f.startsWith("run.") || !f.endsWith(".ts") || f.endsWith(".d.ts"))
+                continue;
+            if (f === "run.ts")
+                continue; // covered above
+            const variant = f.slice(4, -3);
+            out.push({ name: `${entry.name}.${variant}`, entry: resolve(wireDir, f) });
+        }
+    }
+    return out;
+}
+function findSingleAppLayout(cwd, packageName) {
+    const appDir = resolve(cwd, "app");
+    if (!existsSync(appDir) || !statSync(appDir).isDirectory())
+        return [];
+    const e = firstExistingEntry(appDir);
+    return e ? [{ name: packageName, entry: e }] : [];
+}
+function findFlatLayout(cwd, packageName) {
+    for (const dir of [resolve(cwd, "src"), cwd]) {
+        const e = firstExistingEntry(dir);
+        if (e)
+            return [{ name: packageName, entry: e }];
+    }
+    return [];
+}
+function locateConfig(cwd) {
+    for (const name of CONFIG_NAMES) {
+        const p = resolve(cwd, name);
+        if (existsSync(p))
+            return p;
+    }
+    return undefined;
+}
+export function detectLayout(cwd = process.cwd()) {
+    const pkg = readPackage(cwd);
+    const packageName = pkg.name?.replace(/^@[^/]+\//, "") || "app";
+    const configPath = locateConfig(cwd);
+    const declared = pkg.nwire?.wires;
+    if (declared && declared.length > 0) {
+        return {
+            cwd,
+            packageName,
+            configPath,
+            explicit: true,
+            wires: declared.map((d) => ({ name: d.name, entry: resolve(cwd, d.entry) })),
+        };
+    }
+    const appsWires = findAppsLayout(cwd);
+    if (appsWires.length > 0) {
+        return { cwd, packageName, configPath, explicit: false, wires: appsWires };
+    }
+    const singleAppWires = findSingleAppLayout(cwd, packageName);
+    if (singleAppWires.length > 0) {
+        return { cwd, packageName, configPath, explicit: false, wires: singleAppWires };
+    }
+    return {
+        cwd,
+        packageName,
+        configPath,
+        explicit: false,
+        wires: findFlatLayout(cwd, packageName),
+    };
+}
+/**
+ * Resolve a named wire to its entry file. `nwire build foo` calls this
+ * with `foo`; we return the entry path or `undefined` if unknown.
+ */
+export function resolveWire(layout, name) {
+    return layout.wires.find((w) => w.name === name)?.entry;
+}

package/dist/lib/package-manager.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Detect the consumer's package manager from lockfile / packageManager
+ * field. `pnpm` is preferred when ambiguous (matches Nwire's own dev
+ * convention) but the CLI follows whatever the project already uses.
+ */
+export type PackageManager = "pnpm" | "yarn" | "npm" | "bun";
+export declare function detectPackageManager(cwd?: string): PackageManager;
+/**
+ * Build the command + args for `<pm> run <script>`.
+ */
+export declare function runScriptCommand(pm: PackageManager, script: string): [string, string[]];
+/**
+ * Build the command + args for `<pm> exec <bin> [...args]`. yarn 1.x
+ * does not have `exec`; we fall back to invoking `node_modules/.bin/<bin>`
+ * directly for that case.
+ */
+export declare function execBinaryCommand(pm: PackageManager, bin: string, args?: readonly string[]): [string, string[]];