@incajs/cli 0.0.0 → 0.0.2

package/LICENSE

@@ -0,0 +1,5 @@
+Dual-licensed under MIT OR Apache-2.0.
+
+See:
+- https://github.com/tom96da/incajs/blob/main/LICENSE-MIT
+- https://github.com/tom96da/incajs/blob/main/LICENSE-APACHE

package/README.md

@@ -1,2 +1,66 @@
-Name reservation for `@incajs/cli`; the real implementation is still in
-development. See https://github.com/tom96da/incajs.
+<!--
+Copyright (c) 2026 tom96da
+SPDX-License-Identifier: MIT OR Apache-2.0
+-->
+
+# @incajs/cli
+
+The `inca` command for building and running [Incarnative.js](https://github.com/tom96da/incajs)
+apps: `inca dev`, `inca build`, and `inca package`.
+
+## Install
+
+```sh
+npm i -D @incajs/cli
+```
+
+## App entry
+
+No entry point is required. Drop a `src/App.vue` and that's a whole
+app. Commit a `src/main.mts` instead for full control over
+bootstrapping; it wins outright when both exist.
+
+## Commands
+
+- **`inca dev`** — watches your app and opens a live-reloading window,
+  reloading on every change.
+- **`inca build`** — bundles your app for production, once, with no
+  window opened.
+- **`inca package`** — builds your app, then packages it with a
+  prebuilt `inca-host` into a distributable application: a `.app` on
+  macOS, a plain directory on Linux (other platforms aren't supported
+  yet).
+
+When running `inca`, it will automatically try to resolve a config file
+named `inca.config.ts` inside your app's root (other JS/JSON extensions
+are also supported), for app metadata and build settings:
+
+```ts [inca.config.ts]
+import { defineConfig } from "@incajs/cli/config";
+
+export default defineConfig({
+  // the app's display name
+  productName: "Click Counter",
+  // macOS's CFBundleIdentifier or equivalent
+  identifier: "com.example.click-counter",
+  // the packaged app's icon file
+  icon: "assets/icon.icns",
+});
+```
+
+An `identifier` should be world-unique, so `inca package` prints a note
+when it falls back to the generated one rather than using it silently.
+
+## Requirements
+
+`inca`'s host binary is pulled in automatically as a platform-specific
+optional dependency (Linux and macOS on x64/arm64; Windows isn't
+supported yet) — neither Cargo nor Rust are needed. Set `INCA_HOST_BIN`
+to use a specific binary instead, e.g. on a platform with no published
+one yet, or a custom build.
+
+## How it works
+
+`inca dev`/`build`/`package` bundle your app with Vite, then (for `dev`
+and `package`) launch and supervise `inca-host`, the native runtime
+that renders it, as a child process.

package/bin/inca.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 tom96da
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+import { run } from "../dist/cli.js";
+
+await run();

package/dist/adapter/types.d.mts

@@ -0,0 +1,47 @@
+/** A running build watch — the value {@link Bundler.watch} resolves to. */
+export interface Watcher {
+    /** Stops watching and releases the underlying build process. */
+    close(): Promise<void>;
+}
+/** Options for {@link Bundler.watch}. */
+export interface BundlerOptions {
+    /** The app's own entry point — may import `.vue` files. */
+    entry: string;
+    /** Where the build's output is written. */
+    outDir: string;
+    /** `"development"` keeps a framework's own warnings; `"production"` strips them. */
+    mode: "development" | "production";
+    /** Called after each successful (re)build, with what it wrote. */
+    onBuild: (output: BuildOutput) => void;
+    /** Called instead of `onBuild` when a (re)build fails. */
+    onError: (error: {
+        message: string;
+        stack: string | null;
+    }) => void;
+}
+/** Options for {@link Bundler.build}. */
+export interface BuildOptions {
+    /** The app's own entry point — may import `.vue` files. */
+    entry: string;
+    /** Where the build's output is written. */
+    outDir: string;
+}
+/** What a build wrote — the result of {@link Bundler.build}, and every {@link BundlerOptions.onBuild} call. */
+export interface BuildOutput {
+    /** Directory holding every file this build emitted. */
+    outDir: string;
+    /** Absolute path to the entry module `inca-host` evaluates. */
+    entryFile: string;
+    /** Every file this build emitted, relative to `outDir` — may include chunks and assets besides the entry itself. */
+    files: readonly string[];
+}
+/**
+ * The contract a bundler adapter satisfies. Supporting another bundler
+ * means adding a sibling adapter module and injecting its `Bundler` here —
+ * never editing this package's own types.
+ */
+export interface Bundler {
+    watch(options: BundlerOptions): Promise<Watcher>;
+    /** One-shot production build, used by `inca build` — rejects on failure. */
+    build(options: BuildOptions): Promise<BuildOutput>;
+}

package/dist/adapter/vite/build.d.mts

@@ -0,0 +1,8 @@
+import { BuildOptions, BuildOutput } from '../types.mts';
+export type { BuildOptions, BuildOutput } from '../types.mts';
+/**
+ * Builds `entry` into a minified, production build under `outDir` once, and
+ * rejects on failure rather than reporting it through a callback. Never
+ * starts or talks to `inca-host` — that's `dev.mts`'s job.
+ */
+export declare function build({ entry, outDir }: BuildOptions): Promise<BuildOutput>;

package/dist/adapter/vite/captureOutput.d.mts

@@ -0,0 +1,15 @@
+import { Plugin } from 'vite';
+/** What one (re)build actually wrote, relative to its own `outDir`. */
+export interface CapturedOutput {
+    /** The emitted chunk marked as this build's entry. */
+    entryFile: string;
+    /** Every emitted file, as the bundler reported it. */
+    files: readonly string[];
+}
+/**
+ * A Vite plugin reporting `sink` the files a build wrote once they land on
+ * disk, via `writeBundle` — the one hook that fires uniformly for a
+ * one-shot build and every watch rebuild, so both read the bundler's real
+ * output instead of assuming a file name or layout.
+ */
+export declare function captureOutput(sink: (output: CapturedOutput) => void): Plugin;

package/dist/adapter/vite/config.d.mts

@@ -0,0 +1,26 @@
+import { InlineConfig } from 'vite';
+import { CapturedOutput } from './captureOutput.mts';
+export declare const BUNDLE_FILE_NAME = "bundle.js";
+export interface ResolveConfigOptions {
+    /** The app's own entry point — may import `.vue` files. */
+    entry: string;
+    /** Where the build's output is written. */
+    outDir: string;
+    /** `"development"` keeps `@vue/runtime-core`'s own warnings; `"production"` strips them. */
+    mode: "development" | "production";
+    /** Whether Vite should keep rebuilding on file changes. */
+    watch: boolean;
+    /** Called with what each successful (re)build wrote. */
+    onOutput: (output: CapturedOutput) => void;
+}
+/**
+ * Builds the Vite config shared by `watch` and `build`, compiling `.vue`
+ * files via `@vitejs/plugin-vue` targeted at `@vue/runtime-core` rather than
+ * the `vue` meta-package it requires to run.
+ *
+ * An import the entry doesn't inline — a dynamic `import()`, or a `.vue`
+ * file's own `<style>` block — lands as its own chunk or asset alongside
+ * the entry, named by `chunkFileNames`/`assetFileNames` below, rather than
+ * failing the build.
+ */
+export declare function resolveViteConfig({ entry, outDir, mode, watch, onOutput, }: ResolveConfigOptions): InlineConfig;

package/dist/adapter/vite/index.d.mts

@@ -0,0 +1,2 @@
+export { build } from './build.mts';
+export { watch } from './watch.mts';

package/dist/adapter/vite/watch.d.mts

@@ -0,0 +1,8 @@
+import { BundlerOptions, Watcher } from '../types.mts';
+export type { Watcher } from '../types.mts';
+/**
+ * Builds `entry` into a build under `outDir` and rebuilds it on every
+ * change, calling `onBuild` with what each rebuild wrote. Never starts,
+ * reloads, or talks to `inca-host` — that's `dev.mts`'s job.
+ */
+export declare function watch({ onBuild, onError, ...buildOptions }: BundlerOptions): Promise<Watcher>;

package/dist/build.d.mts

@@ -0,0 +1,21 @@
+import { Bundler, BuildOutput } from './adapter/types.mts';
+import { ResolvedBuildConfig } from './config/loader.mts';
+export interface BuildAppOptions {
+    /** The app's root directory. Defaults to `process.cwd()`. */
+    cwd?: string;
+    /**
+     * The app's entry point. Defaults to resolving it automatically: a
+     * committed `src/main.mts`, or `src/App.vue` wrapped in a synthesized one.
+     */
+    entry?: string;
+    /** Overrides the bundler — see {@link defaultBundler} for what's wired in by default. */
+    bundler?: Bundler;
+    /** An already-resolved config — lets `packageApp` avoid loading it twice. */
+    config?: ResolvedBuildConfig;
+}
+/**
+ * Builds the app once through the same bundler `dev` uses, and returns what
+ * it wrote. Rejects on failure — deciding what that means for the process
+ * is `cli.mts`'s job.
+ */
+export declare function build(options?: BuildAppOptions): Promise<BuildOutput>;

package/dist/chunks/__vite-optional-peer-dep_dotenv_c12-CxKvRg9-.js

@@ -0,0 +1,3 @@
+//#region __vite-optional-peer-dep:dotenv:c12
+throw Error("Could not resolve \"dotenv\" imported by \"c12\". Is it installed?");
+//#endregion

package/dist/chunks/__vite-optional-peer-dep_giget_c12-BYcrHYBM.js

@@ -0,0 +1,5 @@
+//#region __vite-optional-peer-dep:giget:c12
+var e = {};
+throw Error("Could not resolve \"giget\" imported by \"c12\". Is it installed?");
+//#endregion
+export { e as default };

package/dist/chunks/__vite-optional-peer-dep_jiti_c12-DZVJNj6v.js

@@ -0,0 +1,5 @@
+//#region __vite-optional-peer-dep:jiti:c12
+var e = {};
+throw Error("Could not resolve \"jiti\" imported by \"c12\". Is it installed?");
+//#endregion
+export { e as default };

package/dist/chunks/_format-BKs7bsc4.js

@@ -0,0 +1,98 @@
+//#region ../../node_modules/.pnpm/confbox@0.3.1/node_modules/confbox/dist/_chunks/libs/detect-indent.mjs
+var e = /^(?:( )+|\t+)/, t = "space";
+function n(e, n, r) {
+	return e && n === t && r === 1;
+}
+function r(r, a) {
+	let o = /* @__PURE__ */ new Map(), s = 0, c, l;
+	for (let u of r.split(/\n/g)) {
+		if (!u) continue;
+		let r = u.match(e);
+		if (r === null) s = 0, c = "";
+		else {
+			let e = r[0].length, u = r[1] ? t : "tab";
+			if (n(a, u, e)) continue;
+			u !== c && (s = 0), c = u;
+			let d = 1, f = 0, p = e - s;
+			if (s = e, p === 0) d = 0, f = 1;
+			else {
+				let e = Math.abs(p);
+				if (n(a, u, e)) continue;
+				l = i(u, e);
+			}
+			let m = o.get(l);
+			o.set(l, m === void 0 ? [1, 0] : [m[0] + d, m[1] + f]);
+		}
+	}
+	return o;
+}
+function i(e, n) {
+	return (e === t ? "s" : "t") + String(n);
+}
+function a(e) {
+	return {
+		type: e[0] === "s" ? t : "tab",
+		amount: Number(e.slice(1))
+	};
+}
+function o(e) {
+	let t, n = 0, r = 0;
+	for (let [i, [a, o]] of e) (a > n || a === n && o > r) && (n = a, r = o, t = i);
+	return t;
+}
+function s(e, n) {
+	return (e === t ? " " : "	").repeat(n);
+}
+function c(e) {
+	if (typeof e != "string") throw TypeError("Expected a string");
+	let t = r(e, !0);
+	t.size === 0 && (t = r(e, !1));
+	let n = o(t), i, c = 0, l = "";
+	return n !== void 0 && ({type: i, amount: c} = a(n), l = s(i, c)), {
+		amount: c,
+		type: i,
+		indent: l
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/confbox@0.3.1/node_modules/confbox/dist/_chunks/_format.mjs
+var l = Symbol.for("__confbox_fmt__"), u = /^(\s+)/, d = /(\s+)$/;
+function f(e) {
+	return e.charCodeAt(0) === 65279 ? e.slice(1) : e;
+}
+function p(e, t = {}) {
+	return {
+		sample: t.indent === void 0 && t.preserveIndentation !== !1 && f(e).slice(0, t?.sampleSize || 1024),
+		whiteSpace: t.preserveWhitespace === !1 ? void 0 : {
+			start: u.exec(e)?.[0] || "",
+			end: d.exec(e)?.[0] || ""
+		}
+	};
+}
+function m(e, t, n) {
+	!t || typeof t != "object" || Object.defineProperty(t, l, {
+		enumerable: !1,
+		configurable: !0,
+		writable: !0,
+		value: p(e, n)
+	});
+}
+function h(e, t) {
+	if (!e || typeof e != "object" || !(l in e)) return {
+		indent: t?.indent ?? 2,
+		whitespace: {
+			start: "",
+			end: ""
+		}
+	};
+	let n = e[l];
+	return {
+		indent: t?.indent || c(n.sample || "").indent,
+		whitespace: n.whiteSpace || {
+			start: "",
+			end: ""
+		}
+	};
+}
+//#endregion
+export { m as n, h as r, f as t };