@kici-dev/compiler 0.1.3 → 0.1.5

package/dist/local-executor/materializer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Materialize an isolated tmp checkout of the repo for `kici run local`.
+ *
+ * Reproduces the same workspace `kici run remote` reconstructs on the agent:
+ * a clone checked out at HEAD, with the local overlay (dirty + untracked,
+ * minus gitignored, with `.kiciignore` applied) copied on top and local
+ * deletions removed. Steps then execute against this copy so the developer's
+ * real working tree is never mutated.
+ *
+ * Secrets are NOT part of the overlay: gitignored files such as
+ * `.kici/.env.local` are excluded by the shared selection, so the tmp checkout
+ * never receives them — the run reads them from the original `.kici/`.
+ */
+/**
+ * A materialized isolated checkout.
+ */
+export interface MaterializedCheckout {
+    /** Absolute path to the tmp checkout directory */
+    path: string;
+    /** Remove the tmp checkout directory */
+    cleanup: () => Promise<void>;
+}
+/**
+ * Options for {@link materializeCheckout}.
+ */
+export interface MaterializeOptions {
+    /** Base directory for the tmp checkout (default: os.tmpdir()) */
+    runDir?: string;
+}
+/**
+ * Materialize the repo at `repoRoot` into an isolated tmp checkout.
+ *
+ * @param repoRoot - Path to the git repository root
+ * @param opts - Optional configuration (tmp base directory)
+ * @returns The tmp checkout path and a cleanup callback
+ * @throws If `repoRoot` is not inside a git work tree
+ */
+export declare function materializeCheckout(repoRoot: string, opts?: MaterializeOptions): Promise<MaterializedCheckout>;
+//# sourceMappingURL=materializer.d.ts.map

package/dist/local-executor/materializer.js

@@ -0,0 +1,111 @@
+import "../chunk-gOLHoazu.js";
+import { selectOverlayFiles } from "../remote/uploader.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import os from "node:os";
+import { randomBytes } from "node:crypto";
+//#region src/local-executor/materializer.ts
+/**
+* Materialize an isolated tmp checkout of the repo for `kici run local`.
+*
+* Reproduces the same workspace `kici run remote` reconstructs on the agent:
+* a clone checked out at HEAD, with the local overlay (dirty + untracked,
+* minus gitignored, with `.kiciignore` applied) copied on top and local
+* deletions removed. Steps then execute against this copy so the developer's
+* real working tree is never mutated.
+*
+* Secrets are NOT part of the overlay: gitignored files such as
+* `.kici/.env.local` are excluded by the shared selection, so the tmp checkout
+* never receives them — the run reads them from the original `.kici/`.
+*/
+/** Max number of overlay files copied concurrently. */
+const COPY_BATCH_SIZE = 32;
+/**
+* Materialize the repo at `repoRoot` into an isolated tmp checkout.
+*
+* @param repoRoot - Path to the git repository root
+* @param opts - Optional configuration (tmp base directory)
+* @returns The tmp checkout path and a cleanup callback
+* @throws If `repoRoot` is not inside a git work tree
+*/
+async function materializeCheckout(repoRoot, opts) {
+	requireGitRepo(repoRoot);
+	const base = opts?.runDir ?? os.tmpdir();
+	await fs.mkdir(base, { recursive: true });
+	const tmpDir = path.join(base, `kici-run-${randomBytes(3).toString("hex")}`);
+	const { sha, existingFiles, deletedFiles } = await selectOverlayFiles(repoRoot);
+	execSync(`git clone --no-hardlinks --quiet ${shellQuote(repoRoot)} ${shellQuote(tmpDir)}`, { stdio: "ignore" });
+	execSync(`git checkout --quiet ${sha}`, {
+		cwd: tmpDir,
+		stdio: "ignore"
+	});
+	await applyOverlay(repoRoot, tmpDir, existingFiles, deletedFiles);
+	return {
+		path: tmpDir,
+		cleanup: async () => {
+			await fs.rm(tmpDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+}
+/**
+* Throw an actionable error if `repoRoot` is not a git work tree.
+*/
+function requireGitRepo(repoRoot) {
+	try {
+		execSync("git rev-parse --is-inside-work-tree", {
+			cwd: repoRoot,
+			stdio: "ignore"
+		});
+	} catch {
+		throw new Error(`kici run local needs a git repository to build an isolated checkout, but "${repoRoot}" is not inside a git work tree. Initialize a repo, or re-run with --in-place to execute against the working directory directly.`);
+	}
+}
+/**
+* Copy the overlay files onto the clone and remove local deletions.
+*/
+async function applyOverlay(repoRoot, tmpDir, existingFiles, deletedFiles) {
+	for (let i = 0; i < existingFiles.length; i += COPY_BATCH_SIZE) {
+		const batch = existingFiles.slice(i, i + COPY_BATCH_SIZE);
+		await Promise.all(batch.map((file) => copyOverlayFile(repoRoot, tmpDir, file)));
+	}
+	for (let i = 0; i < deletedFiles.length; i += COPY_BATCH_SIZE) {
+		const batch = deletedFiles.slice(i, i + COPY_BATCH_SIZE);
+		await Promise.all(batch.map((file) => fs.rm(path.join(tmpDir, file), { force: true })));
+	}
+}
+/**
+* Copy a single overlay file, preserving its mode (e.g. the exec bit).
+*
+* Symlinks are recreated as links rather than dereferenced — the same shape the
+* remote path's tarball preserves. Following them would copy the link target's
+* content (and a directory symlink such as `node_modules/@scope/pkg` would
+* throw `EISDIR`), losing the link identity the workspace relies on.
+*/
+async function copyOverlayFile(repoRoot, tmpDir, file) {
+	const src = path.join(repoRoot, file);
+	const dest = path.join(tmpDir, file);
+	await fs.mkdir(path.dirname(dest), { recursive: true });
+	const srcStat = await fs.lstat(src);
+	if (srcStat.isSymbolicLink()) {
+		const target = await fs.readlink(src);
+		await fs.rm(dest, { force: true });
+		await fs.symlink(target, dest);
+		return;
+	}
+	await fs.copyFile(src, dest);
+	await fs.chmod(dest, srcStat.mode);
+}
+/**
+* Minimal single-quote shell escaping for paths passed to git via execSync.
+*/
+function shellQuote(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+//#endregion
+export { materializeCheckout };
+
+//# sourceMappingURL=materializer.js.map

package/dist/local-executor/types.d.ts

@@ -38,6 +38,10 @@ export interface RunLocalOptions {
     debug?: boolean;
     /** --kici-dir: path to .kici directory */
     kiciDir?: string;
+    /** --in-place: run against the real working directory instead of an isolated tmp checkout */
+    inPlace?: boolean;
+    /** --keep: always retain the isolated tmp checkout (default: keep only on failure) */
+    keep?: boolean;
 }
 /**
  * A job after matrix expansion with resolved values.

package/dist/remote/oauth.d.ts

@@ -4,8 +4,6 @@ interface PkceFlowOptions {
     issuer: string;
     /** OAuth client ID for the CLI application */
     clientId: string;
-    /** OIDC project ID (adds audience scope for JWT access tokens) */
-    projectId?: string;
 }
 /** Options for the RFC 8628 device authorization flow. */
 interface DeviceFlowOptions {
@@ -13,8 +11,6 @@ interface DeviceFlowOptions {
     issuer: string;
     /** OAuth client ID for the CLI application */
     clientId: string;
-    /** OIDC project ID (adds audience scope for JWT access tokens) */
-    projectId?: string;
 }
 /** Options for exchanging an OIDC token for a PAT. */
 interface ExchangeTokenOptions {
@@ -38,8 +34,11 @@ interface ExchangeTokenResult {
  * PKCE authorization code flow with localhost callback.
  *
  * Spins up a temporary HTTP server on a random port, opens the browser
- * to the ZITADEL authorization endpoint, captures the callback with the
- * authorization code, and exchanges it for tokens.
+ * to the IdP's authorization endpoint, captures the callback with the
+ * authorization code, and exchanges it for tokens. The authorization
+ * and token endpoints come from the IdP's OIDC discovery document
+ * (`/.well-known/openid-configuration`) so the same flow works against
+ * any spec-compliant IdP regardless of its URL conventions.
  *
  * @returns OIDC access token
  */
@@ -47,9 +46,11 @@ export declare function pkceFlow(opts: PkceFlowOptions): Promise<string>;
 /**
  * RFC 8628 device authorization flow.
  *
- * Requests a device code from ZITADEL, displays the user code and
+ * Requests a device code from the IdP, displays the user code and
  * verification URI, then polls the token endpoint until the user
- * authorizes the device or the code expires.
+ * authorizes the device or the code expires. Endpoints come from the
+ * OIDC discovery document so the same flow works against any
+ * spec-compliant IdP.
  *
  * @returns OIDC access token
  */

package/dist/remote/oauth.js

@@ -1,4 +1,5 @@
 import "../chunk-gOLHoazu.js";
+import { discoverOidcEndpoints } from "./oidc-discovery.js";
 import pc from "picocolors";
 import { exec } from "node:child_process";
 import { toErrorMessage } from "@kici-dev/shared";
@@ -80,15 +81,16 @@ const SUCCESS_HTML = `<!DOCTYPE html>
 * PKCE authorization code flow with localhost callback.
 *
 * Spins up a temporary HTTP server on a random port, opens the browser
-* to the ZITADEL authorization endpoint, captures the callback with the
-* authorization code, and exchanges it for tokens.
+* to the IdP's authorization endpoint, captures the callback with the
+* authorization code, and exchanges it for tokens. The authorization
+* and token endpoints come from the IdP's OIDC discovery document
+* (`/.well-known/openid-configuration`) so the same flow works against
+* any spec-compliant IdP regardless of its URL conventions.
 *
 * @returns OIDC access token
 */
 async function pkceFlow(opts) {
-	const { issuer, clientId, projectId } = opts;
-	const { verifier, challenge } = generatePkceChallenge();
-	const state = randomBytes(16).toString("hex");
+	const { issuer, clientId } = opts;
 	let listenPort = 0;
 	const callbackPortEnv = process.env.KICI_CALLBACK_PORT;
 	if (callbackPortEnv) {
@@ -96,6 +98,9 @@ async function pkceFlow(opts) {
 		if (isNaN(parsed) || parsed < 0) throw new Error(`KICI_CALLBACK_PORT must be a valid non-negative integer, got: "${callbackPortEnv}"`);
 		listenPort = parsed;
 	}
+	const endpoints = await discoverOidcEndpoints(issuer);
+	const { verifier, challenge } = generatePkceChallenge();
+	const state = randomBytes(16).toString("hex");
 	const TIMEOUT_MS = 300 * 1e3;
 	return new Promise((resolve, reject) => {
 		let timer;
@@ -135,7 +140,7 @@ async function pkceFlow(opts) {
 			res.end(SUCCESS_HTML);
 			const port = server.address().port;
 			try {
-				const tokenRes = await fetchOrThrow(`${issuer}/oauth/v2/token`, {
+				const tokenRes = await fetchOrThrow(endpoints.token_endpoint, {
 					method: "POST",
 					headers: { "Content-Type": "application/x-www-form-urlencoded" },
 					body: new URLSearchParams({
@@ -145,7 +150,7 @@ async function pkceFlow(opts) {
 						redirect_uri: `http://127.0.0.1:${port}/callback`,
 						code_verifier: verifier
 					})
-				}, "Zitadel");
+				}, "IdP");
 				if (!tokenRes.ok) {
 					const errorBody = await tokenRes.text();
 					cleanup();
@@ -167,18 +172,16 @@ async function pkceFlow(opts) {
 		server.listen(listenPort, "127.0.0.1", () => {
 			const actualPort = server.address().port;
 			const redirectUri = `http://127.0.0.1:${actualPort}/callback`;
-			const authUrl = new URL(`${issuer}/oauth/v2/authorize`);
+			const authUrl = new URL(endpoints.authorization_endpoint);
 			authUrl.searchParams.set("client_id", clientId);
 			authUrl.searchParams.set("redirect_uri", redirectUri);
 			authUrl.searchParams.set("response_type", "code");
-			const scopes = [
+			authUrl.searchParams.set("scope", [
 				"openid",
 				"profile",
 				"email",
 				"offline_access"
-			];
-			if (projectId) scopes.push(`urn:zitadel:iam:org:project:id:${projectId}:aud`);
-			authUrl.searchParams.set("scope", scopes.join(" "));
+			].join(" "));
 			authUrl.searchParams.set("code_challenge", challenge);
 			authUrl.searchParams.set("code_challenge_method", "S256");
 			authUrl.searchParams.set("state", state);
@@ -209,29 +212,34 @@ function sleep(ms) {
 /**
 * RFC 8628 device authorization flow.
 *
-* Requests a device code from ZITADEL, displays the user code and
+* Requests a device code from the IdP, displays the user code and
 * verification URI, then polls the token endpoint until the user
-* authorizes the device or the code expires.
+* authorizes the device or the code expires. Endpoints come from the
+* OIDC discovery document so the same flow works against any
+* spec-compliant IdP.
 *
 * @returns OIDC access token
 */
 async function deviceFlow(opts) {
-	const { issuer, clientId, projectId } = opts;
+	const { issuer, clientId } = opts;
+	const endpoints = await discoverOidcEndpoints(issuer);
 	const scopes = [
 		"openid",
 		"profile",
 		"email",
 		"offline_access"
 	];
-	if (projectId) scopes.push(`urn:zitadel:iam:org:project:id:${projectId}:aud`);
-	const deviceAuthRes = await fetchOrThrow(`${issuer}/oauth/v2/device_authorization`, {
+	const { verifier, challenge } = generatePkceChallenge();
+	const deviceAuthRes = await fetchOrThrow(endpoints.device_authorization_endpoint, {
 		method: "POST",
 		headers: { "Content-Type": "application/x-www-form-urlencoded" },
 		body: new URLSearchParams({
 			client_id: clientId,
-			scope: scopes.join(" ")
+			scope: scopes.join(" "),
+			code_challenge: challenge,
+			code_challenge_method: "S256"
 		})
-	}, "Zitadel");
+	}, "IdP");
 	if (!deviceAuthRes.ok) {
 		const errorBody = await deviceAuthRes.text();
 		throw new Error(`Device authorization request failed: ${errorBody}`);
@@ -241,7 +249,7 @@ async function deviceFlow(opts) {
 	console.log(pc.bold("  Device authorization"));
 	if (deviceAuth.verification_uri_complete) {
 		console.log(`  Open ${pc.cyan(deviceAuth.verification_uri_complete)}`);
-		console.log(pc.gray("  The code is pre-filled; approve on the Zitadel screen."));
+		console.log(pc.gray("  The code is pre-filled; approve on the IdP screen."));
 		console.log(pc.gray(`  Enter code: ${pc.bold(pc.yellow(deviceAuth.user_code))} (if prompted)`));
 	} else {
 		console.log(`  Open ${pc.cyan(deviceAuth.verification_uri)}`);
@@ -252,15 +260,16 @@ async function deviceFlow(opts) {
 	let intervalMs = (deviceAuth.interval ?? 5) * 1e3;
 	while (true) {
 		await sleep(intervalMs);
-		const tokenRes = await fetchOrThrow(`${issuer}/oauth/v2/token`, {
+		const tokenRes = await fetchOrThrow(endpoints.token_endpoint, {
 			method: "POST",
 			headers: { "Content-Type": "application/x-www-form-urlencoded" },
 			body: new URLSearchParams({
 				client_id: clientId,
 				grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-				device_code: deviceAuth.device_code
+				device_code: deviceAuth.device_code,
+				code_verifier: verifier
 			})
-		}, "Zitadel");
+		}, "IdP");
 		if (tokenRes.ok) return (await tokenRes.json()).access_token;
 		const errorData = await tokenRes.json();
 		switch (errorData.error) {

package/dist/remote/oidc-discovery.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Endpoints the CLI's OAuth flows need from an OIDC IdP. A subset of the
+ * full OIDC Provider Metadata schema (RFC 8414 / OpenID Connect Discovery
+ * 1.0) — we only consume what `pkceFlow` / `deviceFlow` actually call.
+ */
+export interface OidcDiscoveryEndpoints {
+    /** Issuer claim — used for sanity-checking the discovery document. */
+    issuer: string;
+    /** RFC 6749 authorization endpoint (PKCE). */
+    authorization_endpoint: string;
+    /** RFC 6749 token endpoint (PKCE code exchange + device-flow polling). */
+    token_endpoint: string;
+    /** RFC 8628 device authorization endpoint. */
+    device_authorization_endpoint: string;
+}
+/**
+ * Test-only escape hatch. Clears the per-process cache so a subsequent
+ * `discoverOidcEndpoints` call re-fetches the metadata document.
+ */
+export declare function resetDiscoveryCache(): void;
+/**
+ * Fetch and parse the OIDC Provider Metadata document for an issuer URL,
+ * then return the endpoints the CLI needs. Cached per-process so a `kici
+ * login` invocation makes at most one discovery round-trip.
+ *
+ * The issuer is treated as a base URL — trailing slashes are stripped and
+ * `/.well-known/openid-configuration` is appended. This works for the two
+ * IdP shapes the CLI authenticates against:
+ *
+ *   - Keycloak: issuer = `https://auth.example.com/realms/<name>` (path-segment).
+ *   - Keycloak: issuer = `https://auth.example.com/realms/<realm>`
+ *     (realm-scoped — discovery lives at `<issuer>/.well-known/...`).
+ *
+ * Throws with an actionable message if discovery is unreachable (DNS,
+ * connection refused, TLS handshake), returns a non-2xx status, fails to
+ * parse as JSON, or omits any of the four required fields.
+ */
+export declare function discoverOidcEndpoints(issuer: string): Promise<OidcDiscoveryEndpoints>;
+//# sourceMappingURL=oidc-discovery.d.ts.map

package/dist/remote/oidc-discovery.js

@@ -0,0 +1,72 @@
+import "../chunk-gOLHoazu.js";
+import { toErrorMessage } from "@kici-dev/shared";
+//#region src/remote/oidc-discovery.ts
+const cache = /* @__PURE__ */ new Map();
+/**
+* Test-only escape hatch. Clears the per-process cache so a subsequent
+* `discoverOidcEndpoints` call re-fetches the metadata document.
+*/
+function resetDiscoveryCache() {
+	cache.clear();
+}
+/**
+* Fetch and parse the OIDC Provider Metadata document for an issuer URL,
+* then return the endpoints the CLI needs. Cached per-process so a `kici
+* login` invocation makes at most one discovery round-trip.
+*
+* The issuer is treated as a base URL — trailing slashes are stripped and
+* `/.well-known/openid-configuration` is appended. This works for the two
+* IdP shapes the CLI authenticates against:
+*
+*   - Keycloak: issuer = `https://auth.example.com/realms/<name>` (path-segment).
+*   - Keycloak: issuer = `https://auth.example.com/realms/<realm>`
+*     (realm-scoped — discovery lives at `<issuer>/.well-known/...`).
+*
+* Throws with an actionable message if discovery is unreachable (DNS,
+* connection refused, TLS handshake), returns a non-2xx status, fails to
+* parse as JSON, or omits any of the four required fields.
+*/
+async function discoverOidcEndpoints(issuer) {
+	const base = issuer.trim().replace(/\/+$/, "");
+	if (!base) throw new Error("[oidc-discovery] issuer is empty");
+	const cached = cache.get(base);
+	if (cached) return cached;
+	const url = `${base}/.well-known/openid-configuration`;
+	let res;
+	try {
+		res = await fetch(url, { method: "GET" });
+	} catch (err) {
+		throw new Error(`Could not reach IdP discovery at ${url} (${toErrorMessage(err)}). Check KICI_OIDC_ISSUER.`);
+	}
+	if (!res.ok) throw new Error(`IdP discovery at ${url} returned HTTP ${res.status} ${res.statusText}`);
+	let body;
+	try {
+		body = await res.json();
+	} catch (err) {
+		throw new Error(`IdP discovery at ${url} returned non-JSON body: ${toErrorMessage(err)}`);
+	}
+	const parsed = parseEndpoints(body, url);
+	cache.set(base, parsed);
+	return parsed;
+}
+function parseEndpoints(body, url) {
+	if (!body || typeof body !== "object") throw new Error(`IdP discovery at ${url} returned a non-object payload.`);
+	const obj = body;
+	const missing = [
+		"issuer",
+		"authorization_endpoint",
+		"token_endpoint",
+		"device_authorization_endpoint"
+	].filter((k) => typeof obj[k] !== "string" || !obj[k]);
+	if (missing.length > 0) throw new Error(`IdP discovery at ${url} is missing required field(s): ${missing.join(", ")}. The OIDC IdP must advertise authorization_endpoint, token_endpoint, and device_authorization_endpoint via /.well-known/openid-configuration.`);
+	return {
+		issuer: String(obj.issuer),
+		authorization_endpoint: String(obj.authorization_endpoint),
+		token_endpoint: String(obj.token_endpoint),
+		device_authorization_endpoint: String(obj.device_authorization_endpoint)
+	};
+}
+//#endregion
+export { discoverOidcEndpoints, resetDiscoveryCache };
+
+//# sourceMappingURL=oidc-discovery.js.map

package/dist/remote/uploader.d.ts

@@ -51,6 +51,41 @@ interface UploadResult {
     /** Encrypted tarball size in bytes */
     encryptedSize: number;
 }
+/**
+ * Result of selecting which files form the overlay over a clone at HEAD.
+ *
+ * Both the remote uploader and the local materializer consume this so the two
+ * paths reconstruct the same workspace from the same selection logic.
+ */
+export interface OverlaySelection {
+    /** HEAD SHA the selection is based on */
+    sha: string;
+    /** Whether the repo has at least one git remote */
+    hasRemote: boolean;
+    /** Selected files that exist on disk (to copy onto the clone) */
+    existingFiles: string[];
+    /** Selected files missing on disk (to delete from the clone) */
+    deletedFiles: string[];
+}
+/**
+ * Select which files form the overlay over a clone checked out at HEAD.
+ *
+ * For repos with a remote: collects only dirty files (staged, unstaged, untracked).
+ * For repos without a remote: collects ALL tracked + untracked files.
+ *
+ * The selected set is filtered by `.kiciignore` (picomatch) and partitioned
+ * into files that still exist on disk (to copy onto the clone) and files that
+ * are missing (to delete from the clone). Gitignored files — including secret
+ * files like `.kici/.env.local` — are excluded by `--exclude-standard` and
+ * never appear in the selection.
+ *
+ * @param repoRoot - Path to the git repository root
+ * @param options - Optional configuration
+ * @returns HEAD SHA, remote flag, and the existing/deleted file partition
+ */
+export declare function selectOverlayFiles(repoRoot: string, options?: {
+    kiciIgnorePath?: string;
+}): Promise<OverlaySelection>;
 /**
  * Create an overlay tarball from a git repo, including only changed files.
  *

package/dist/remote/uploader.js

@@ -45,19 +45,22 @@ async function loadKiciIgnore(kiciIgnorePath) {
 	}
 }
 /**
-* Create an overlay tarball from a git repo, including only changed files.
+* Select which files form the overlay over a clone checked out at HEAD.
 *
 * For repos with a remote: collects only dirty files (staged, unstaged, untracked).
-* For repos without a remote: collects ALL tracked + untracked files (full tarball).
+* For repos without a remote: collects ALL tracked + untracked files.
 *
-* The tarball includes a `manifest.json` with the HEAD SHA, deletions list,
-* and SHA256 checksums for integrity verification.
+* The selected set is filtered by `.kiciignore` (picomatch) and partitioned
+* into files that still exist on disk (to copy onto the clone) and files that
+* are missing (to delete from the clone). Gitignored files — including secret
+* files like `.kici/.env.local` — are excluded by `--exclude-standard` and
+* never appear in the selection.
 *
 * @param repoRoot - Path to the git repository root
 * @param options - Optional configuration
-* @returns Tarball path, upload summary, and overlay manifest
+* @returns HEAD SHA, remote flag, and the existing/deleted file partition
 */
-async function createOverlayTarball(repoRoot, options) {
+async function selectOverlayFiles(repoRoot, options) {
 	const sha = execSync("git rev-parse HEAD", {
 		cwd: repoRoot,
 		encoding: "utf-8"
@@ -91,6 +94,28 @@ async function createOverlayTarball(repoRoot, options) {
 			deletedFiles.push(file);
 		}
 	}));
+	return {
+		sha,
+		hasRemote,
+		existingFiles,
+		deletedFiles
+	};
+}
+/**
+* Create an overlay tarball from a git repo, including only changed files.
+*
+* For repos with a remote: collects only dirty files (staged, unstaged, untracked).
+* For repos without a remote: collects ALL tracked + untracked files (full tarball).
+*
+* The tarball includes a `manifest.json` with the HEAD SHA, deletions list,
+* and SHA256 checksums for integrity verification.
+*
+* @param repoRoot - Path to the git repository root
+* @param options - Optional configuration
+* @returns Tarball path, upload summary, and overlay manifest
+*/
+async function createOverlayTarball(repoRoot, options) {
+	const { sha, hasRemote, existingFiles, deletedFiles } = await selectOverlayFiles(repoRoot, options);
 	const untrackedSet = new Set(gitLines("git ls-files --others --exclude-standard", repoRoot));
 	const newFiles = existingFiles.filter((f) => untrackedSet.has(f));
 	const modifiedFiles = existingFiles.filter((f) => !untrackedSet.has(f));
@@ -192,6 +217,6 @@ async function uploadTarball(opts) {
 	throw new Error(`Upload failed after ${MAX_RETRIES} attempts: ${lastError?.message}`);
 }
 //#endregion
-export { createOverlayTarball, getSizeWarning, uploadTarball };
+export { createOverlayTarball, getSizeWarning, selectOverlayFiles, uploadTarball };
 
 //# sourceMappingURL=uploader.js.map

package/dist/templates/package-json.js

@@ -1,6 +1,6 @@
 import "../chunk-gOLHoazu.js";
 //#region src/templates/package-json.ts
-const sdkVersion = "0.1.3";
+const sdkVersion = "0.1.5";
 /**
 * Generate package.json content for .kici/ directory
 *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kici-dev/compiler",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Compiler and CLI for KiCI workflows. Compiles `.kici/workflows/*.ts` to a `kici.lock.json` file consumed by the orchestrator and agents, and runs workflows locally or against a remote orchestrator.",
   "keywords": [
     "kici",
@@ -23,7 +23,6 @@
     "node": ">=24"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
   "type": "module",
@@ -59,11 +58,11 @@
     "ws": "^8.20.0",
     "yaml": "^2.8.3",
     "zx": "^8.8.5",
-    "@kici-dev/engine": "0.1.3",
-    "@kici-dev/shared": "0.1.3"
+    "@kici-dev/engine": "0.1.5",
+    "@kici-dev/shared": "0.1.5"
   },
   "peerDependencies": {
-    "@kici-dev/sdk": "0.1.3"
+    "@kici-dev/sdk": "0.1.5"
   },
   "devDependencies": {
     "@types/proper-lockfile": "^4.1.4"