@irogane/kaji 0.2.0-beta.11 → 0.3.0

package/dist/cli/chunk-SEBX54TR.js

@@ -1,681 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli/init.ts
-import { randomUUID } from "crypto";
-import { spawn } from "child_process";
-import { once } from "events";
-import { constants, existsSync, lstatSync, mkdirSync, readFileSync } from "fs";
-import { link, lstat as lstatAsync, mkdtemp, open, rename, rm, writeFile } from "fs/promises";
-import { basename, isAbsolute, join, resolve } from "path";
-import { fileURLToPath } from "url";
-var PROVIDERS = ["mock", "openai", "anthropic"];
-var CliArgError = class extends Error {
-};
-var WORKER_INPUT_LIMIT_BYTES = 256 * 1024;
-var WORKER_OUTPUT_LIMIT_BYTES = 8 * 1024;
-var WORKER_TIMEOUT_MS = 15e3;
-var WORKER_COMMIT = "commit";
-var WORKER_CANCEL = "cancel";
-var WORKER_PREPARED = '{"prepared":true}';
-var WORKER_SUCCESS = '{"ok":true}';
-var RECOVERY_DIRECTORY = /^\.kaji-scaffold-backup-[A-Za-z0-9]{6}$/;
-function safeRecoveryDirectory(value) {
-  return typeof value === "string" && RECOVERY_DIRECTORY.test(value) ? value : void 0;
-}
-var ScaffoldRollbackError = class extends Error {
-  recoveryDirectory;
-  constructor(recoveryDirectory, cause) {
-    const safeDirectory = safeRecoveryDirectory(recoveryDirectory);
-    if (safeDirectory === void 0) throw new Error("invalid scaffold recovery directory");
-    super("scaffold publication rollback failed", { cause });
-    this.name = "ScaffoldRollbackError";
-    this.recoveryDirectory = safeDirectory;
-  }
-};
-function scaffoldRecoveryDirectory(error) {
-  return error instanceof ScaffoldRollbackError ? error.recoveryDirectory : void 0;
-}
-function throwIfCancelled(signal) {
-  if (signal?.aborted) throw new Error("scaffold worker cancelled");
-}
-function parseArgs(rest) {
-  let positionalPath;
-  let provider = "mock";
-  let force = false;
-  for (let index = 0; index < rest.length; index++) {
-    const arg = rest[index];
-    if (arg === "--provider") {
-      const next = rest[index + 1];
-      if (next === void 0 || next.startsWith("--")) {
-        throw new CliArgError("--provider requires a value");
-      }
-      if (!PROVIDERS.includes(next)) {
-        throw new CliArgError("--provider must be mock, openai, or anthropic");
-      }
-      provider = next;
-      index++;
-    } else if (arg === "--force") {
-      force = true;
-    } else if (arg === "--yes") {
-    } else if (arg.startsWith("--")) {
-      throw new CliArgError(`unknown argument: ${arg}`);
-    } else if (positionalPath === void 0) {
-      positionalPath = arg;
-    } else {
-      throw new CliArgError(`unexpected path argument: ${arg}`);
-    }
-  }
-  return {
-    out: resolve(positionalPath ?? "."),
-    provider,
-    force
-  };
-}
-function installedMetadata() {
-  const path = new URL("../../package.json", import.meta.url);
-  const value = JSON.parse(readFileSync(path, "utf8"));
-  if (typeof value.version !== "string" || value.version.length === 0 || value.peerDependencies === void 0 || value.devDependencies === void 0) {
-    throw new Error("installed kaji package metadata is incomplete");
-  }
-  return value;
-}
-function agentSource(provider) {
-  const providerImports = {
-    mock: 'import { MockProvider } from "@irogane/kaji/testing";',
-    openai: 'import { OpenAIProvider } from "@irogane/kaji/openai";',
-    anthropic: 'import { AnthropicProvider } from "@irogane/kaji/anthropic";'
-  };
-  const providerSetup = {
-    mock: "const provider = new MockProvider();",
-    openai: `const environment = (globalThis as unknown as { process: { env: Record<string, string | undefined> } }).process.env;
-const apiKey = environment.OPENAI_API_KEY;
-if (!apiKey) throw new Error("OPENAI_API_KEY is required for the openai scaffold");
-const provider = new OpenAIProvider({ apiKey });`,
-    anthropic: `const environment = (globalThis as unknown as { process: { env: Record<string, string | undefined> } }).process.env;
-const apiKey = environment.ANTHROPIC_API_KEY;
-if (!apiKey) throw new Error("ANTHROPIC_API_KEY is required for the anthropic scaffold");
-const provider = new AnthropicProvider({ apiKey });`
-  };
-  return `import { AgentBuilder } from "@irogane/kaji";
-${providerImports[provider]}
-
-${providerSetup[provider]}
-const runtime = new AgentBuilder().provider(provider).build();
-const result = await runtime.turn("Say hello.");
-const finalSequence = Math.max(...result.events.map((event) => event.sequence));
-console.log(\`text=\${result.text}\`);
-console.log(\`turn_id=\${result.turnId}\`);
-console.log(\`final_sequence=\${finalSequence}\`);
-`;
-}
-function scaffoldFiles(provider) {
-  const metadata = installedMetadata();
-  const zodRange = metadata.peerDependencies.zod;
-  if (zodRange === void 0) throw new Error("installed kaji has no Zod peer range");
-  const nodeTypesRange = metadata.devDependencies["@types/node"];
-  if (nodeTypesRange === void 0) {
-    throw new Error("installed kaji has no supported @types/node range");
-  }
-  const dotenvxVersion = metadata.devDependencies["@dotenvx/dotenvx"];
-  if (dotenvxVersion === void 0) {
-    throw new Error("installed kaji has no supported dotenvx version");
-  }
-  const dependencies = {
-    "@irogane/kaji": metadata.version,
-    zod: zodRange
-  };
-  if (provider === "openai") {
-    const range = metadata.peerDependencies.openai;
-    if (range === void 0) throw new Error("installed kaji has no OpenAI peer range");
-    dependencies.openai = range;
-  } else if (provider === "anthropic") {
-    const range = metadata.peerDependencies["@anthropic-ai/sdk"];
-    if (range === void 0) throw new Error("installed kaji has no Anthropic peer range");
-    dependencies["@anthropic-ai/sdk"] = range;
-  }
-  return {
-    "package.json": JSON.stringify(
-      {
-        name: "my-kaji-agent",
-        version: "0.1.0",
-        private: true,
-        type: "module",
-        scripts: {
-          start: "dotenvx run --ignore=MISSING_ENV_FILE -- tsx agent.ts",
-          typecheck: "tsc --noEmit"
-        },
-        dependencies,
-        devDependencies: {
-          "@dotenvx/dotenvx": dotenvxVersion,
-          "@types/node": nodeTypesRange,
-          tsx: "^4.0.0",
-          typescript57: metadata.devDependencies.typescript57 ?? "npm:typescript@5.7.3",
-          typescript: metadata.devDependencies.typescript ?? "^6.0.0"
-        }
-      },
-      null,
-      2
-    ),
-    "tsconfig.json": JSON.stringify(
-      {
-        compilerOptions: {
-          target: "ES2022",
-          module: "ESNext",
-          moduleResolution: "Bundler",
-          strict: true,
-          esModuleInterop: true,
-          skipLibCheck: false,
-          types: ["node"]
-        },
-        include: ["*.ts"]
-      },
-      null,
-      2
-    ),
-    "agent.ts": agentSource(provider),
-    ".env.example": provider === "mock" ? "# No provider credentials required.\n" : provider === "openai" ? "OPENAI_API_KEY=\n" : "ANTHROPIC_API_KEY=\n"
-  };
-}
-function destinationKind(path) {
-  try {
-    const stat = lstatSync(path);
-    if (stat.isSymbolicLink()) return "symlink";
-    return stat.isFile() ? "file" : "other";
-  } catch (error) {
-    if (error.code === "ENOENT") return "missing";
-    throw error;
-  }
-}
-function validateWorkerRequest(value) {
-  if (typeof value !== "object" || value === null) {
-    throw new Error("invalid scaffold worker request");
-  }
-  const request = value;
-  if (request.version !== 1 || typeof request.expectedDev !== "string" || !/^\d+$/.test(request.expectedDev) || typeof request.expectedIno !== "string" || !/^\d+$/.test(request.expectedIno) || typeof request.targetAbsolute !== "string" || !isAbsolute(request.targetAbsolute) || typeof request.files !== "object" || request.files === null || Array.isArray(request.files) || typeof request.force !== "boolean") {
-    throw new Error("invalid scaffold worker request");
-  }
-  const entries = Object.entries(request.files);
-  if (entries.length === 0 || entries.length > 32 || entries.some(
-    ([name, body]) => name.length === 0 || name === "." || name === ".." || basename(name) !== name || name.includes("\0") || typeof body !== "string"
-  )) {
-    throw new Error("invalid scaffold worker request");
-  }
-  return request;
-}
-async function assertTargetIdentity(targetAbsolute, expectedDev, expectedIno) {
-  let targetStat;
-  try {
-    targetStat = await lstatAsync(targetAbsolute, { bigint: true });
-  } catch {
-    throw new Error("target directory changed during scaffold publication");
-  }
-  if (!targetStat.isDirectory() || targetStat.isSymbolicLink() || targetStat.dev !== expectedDev || targetStat.ino !== expectedIno) {
-    throw new Error("target directory changed during scaffold publication");
-  }
-}
-async function runInitWorkerRequest(requestValue, options = {}) {
-  const request = validateWorkerRequest(requestValue);
-  const expectedDev = BigInt(request.expectedDev);
-  const expectedIno = BigInt(request.expectedIno);
-  throwIfCancelled(options.signal);
-  const cwdStat = await lstatAsync(".", { bigint: true });
-  throwIfCancelled(options.signal);
-  if (!cwdStat.isDirectory() || cwdStat.dev !== expectedDev || cwdStat.ino !== expectedIno) {
-    throw new Error("pinned scaffold directory identity mismatch");
-  }
-  await options.afterHandshake?.();
-  throwIfCancelled(options.signal);
-  await writeScaffoldFiles(".", request.files, request.force, {
-    beforePublish: options.beforePublish,
-    publish: options.publish,
-    signal: options.signal,
-    verifyTarget: () => assertTargetIdentity(request.targetAbsolute, expectedDev, expectedIno)
-  });
-}
-var WorkerInput = class {
-  buffer = Buffer.alloc(0);
-  bytes = 0;
-  async readLine(signal) {
-    for (; ; ) {
-      const newline = this.buffer.indexOf(10);
-      if (newline >= 0) {
-        const line = this.buffer.subarray(0, newline);
-        this.buffer = this.buffer.subarray(newline + 1);
-        return line.at(-1) === 13 ? line.subarray(0, line.byteLength - 1).toString("utf8") : line.toString("utf8");
-      }
-      const value = process.stdin.read();
-      if (value !== null) {
-        const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
-        this.bytes += chunk.byteLength;
-        if (this.bytes > WORKER_INPUT_LIMIT_BYTES) {
-          throw new Error("scaffold worker input exceeded limit");
-        }
-        this.buffer = Buffer.concat([this.buffer, chunk]);
-        continue;
-      }
-      if (process.stdin.readableEnded) {
-        if (this.buffer.byteLength === 0) throw new Error("scaffold worker input ended early");
-        const line = this.buffer.toString("utf8");
-        this.buffer = Buffer.alloc(0);
-        return line;
-      }
-      await once(process.stdin, "readable", { signal });
-    }
-  }
-};
-async function runInitWorkerMain() {
-  const controller = new AbortController();
-  const cancel = () => controller.abort();
-  let timeout = setTimeout(cancel, WORKER_TIMEOUT_MS);
-  process.once("SIGTERM", cancel);
-  const input = new WorkerInput();
-  try {
-    const request = JSON.parse(await input.readLine(controller.signal));
-    await runInitWorkerRequest(request, {
-      signal: controller.signal,
-      beforePublish: async () => {
-        throwIfCancelled(controller.signal);
-        clearTimeout(timeout);
-        timeout = setTimeout(cancel, WORKER_TIMEOUT_MS);
-        process.stdout.write(`${WORKER_PREPARED}
-`);
-        const command = await input.readLine(controller.signal);
-        if (command !== WORKER_COMMIT) throw new Error("scaffold worker cancelled");
-        throwIfCancelled(controller.signal);
-        clearTimeout(timeout);
-      }
-    });
-  } finally {
-    clearTimeout(timeout);
-    process.removeListener("SIGTERM", cancel);
-  }
-}
-function workerRecoveryLine(line) {
-  try {
-    const value = JSON.parse(line);
-    if (typeof value !== "object" || value === null) return void 0;
-    const record = value;
-    if (record.ok !== false || Object.keys(record).sort().join(",") !== "ok,recovery") {
-      return void 0;
-    }
-    return safeRecoveryDirectory(record.recovery);
-  } catch {
-    return void 0;
-  }
-}
-function safeTimeout(value) {
-  return value !== void 0 && Number.isSafeInteger(value) && value > 0 ? value : WORKER_TIMEOUT_MS;
-}
-async function invokeInitWorkerProcess(request, options = {}) {
-  const payload = JSON.stringify(request);
-  if (Buffer.byteLength(`${payload}
-${WORKER_COMMIT}
-`) > WORKER_INPUT_LIMIT_BYTES) {
-    throw new Error("pinned scaffold worker failed");
-  }
-  const workerPath = fileURLToPath(new URL("./init-worker.js", import.meta.url));
-  const workerExecutable = typeof process.versions.bun === "string" ? process.env.NODE_BINARY ?? "node" : process.execPath;
-  const workerEnvironment = { ...process.env };
-  delete workerEnvironment.NODE_OPTIONS;
-  delete workerEnvironment.NODE_PATH;
-  const command = options.command ?? [workerExecutable, workerPath];
-  const startupTimeoutMs = safeTimeout(options.startupTimeoutMs);
-  const transactionTimeoutMs = safeTimeout(options.transactionTimeoutMs);
-  await new Promise((resolveWorker, rejectWorker) => {
-    const child = spawn(command[0], command.slice(1), {
-      cwd: request.targetAbsolute,
-      env: workerEnvironment,
-      stdio: ["pipe", "pipe", "pipe"],
-      windowsHide: true
-    });
-    let stdoutBuffer = "";
-    let stdoutBytes = 0;
-    let stderrBytes = 0;
-    let failed = false;
-    let settled = false;
-    let prepared = false;
-    let succeeded = false;
-    let recoveryDirectory;
-    let timer;
-    const finish = (error) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      if (error === void 0) resolveWorker();
-      else rejectWorker(error);
-    };
-    const cancelWorker = () => {
-      if (settled) return;
-      failed = true;
-      if (!child.stdin.destroyed && child.stdin.writable) child.stdin.end(`${WORKER_CANCEL}
-`);
-      child.kill("SIGTERM");
-    };
-    const armTimeout = (durationMs) => {
-      clearTimeout(timer);
-      timer = setTimeout(cancelWorker, durationMs);
-    };
-    const authorizeCommit = async () => {
-      try {
-        await options.beforeCommit?.();
-      } catch {
-        cancelWorker();
-        return;
-      }
-      if (!failed && !settled && !child.stdin.destroyed && child.stdin.writable) {
-        clearTimeout(timer);
-        child.stdin.end(`${WORKER_COMMIT}
-`);
-      }
-    };
-    const consumeLine = (line) => {
-      if (!prepared && line === WORKER_PREPARED) {
-        prepared = true;
-        armTimeout(transactionTimeoutMs);
-        void authorizeCommit();
-        return;
-      }
-      if (prepared && !succeeded && line === WORKER_SUCCESS) {
-        succeeded = true;
-        return;
-      }
-      const recovery = workerRecoveryLine(line);
-      if (recovery !== void 0 && recoveryDirectory === void 0) {
-        recoveryDirectory = recovery;
-        return;
-      }
-      cancelWorker();
-    };
-    const consume = (chunk, stream) => {
-      if (stream === "stdout") {
-        stdoutBytes += chunk.byteLength;
-        if (stdoutBytes <= WORKER_OUTPUT_LIMIT_BYTES) {
-          stdoutBuffer += chunk.toString("utf8");
-          for (; ; ) {
-            const newline = stdoutBuffer.indexOf("\n");
-            if (newline < 0) break;
-            const line = stdoutBuffer.slice(0, newline);
-            stdoutBuffer = stdoutBuffer.slice(newline + 1);
-            consumeLine(line);
-          }
-        }
-      } else {
-        stderrBytes += chunk.byteLength;
-      }
-      if (stdoutBytes > WORKER_OUTPUT_LIMIT_BYTES || stderrBytes > WORKER_OUTPUT_LIMIT_BYTES) {
-        cancelWorker();
-      }
-    };
-    armTimeout(startupTimeoutMs);
-    child.stdout.on("data", (chunk) => consume(chunk, "stdout"));
-    child.stderr.on("data", (chunk) => consume(chunk, "stderr"));
-    child.stdin.on("error", cancelWorker);
-    child.on("error", () => finish(new Error("pinned scaffold worker failed")));
-    child.on("close", (code) => {
-      if (recoveryDirectory !== void 0) {
-        finish(new ScaffoldRollbackError(recoveryDirectory));
-      } else if (!failed && code === 0 && prepared && succeeded && stdoutBuffer.length === 0) {
-        finish();
-      } else {
-        finish(new Error("pinned scaffold worker failed"));
-      }
-    });
-    child.stdin.write(`${payload}
-`);
-  });
-}
-async function runPinnedInitWorker(out, files, force, options = {}) {
-  const targetAbsolute = resolve(out);
-  let directory;
-  try {
-    directory = await open(
-      targetAbsolute,
-      constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW
-    );
-  } catch (error) {
-    if (["ELOOP", "ENOTDIR"].includes(error.code ?? "")) {
-      throw new Error("unsafe scaffold destination: symbolic links are not allowed");
-    }
-    throw error;
-  }
-  try {
-    const targetStat = await directory.stat({ bigint: true });
-    if (!targetStat.isDirectory()) {
-      throw new Error("unsafe scaffold destination: target is not a directory");
-    }
-    const request = {
-      version: 1,
-      expectedDev: targetStat.dev.toString(),
-      expectedIno: targetStat.ino.toString(),
-      targetAbsolute,
-      files,
-      force
-    };
-    try {
-      await (options.invokeWorker ?? invokeInitWorkerProcess)(request);
-    } catch (error) {
-      if (error instanceof ScaffoldRollbackError) throw error;
-      throw new Error("pinned scaffold worker failed");
-    }
-  } finally {
-    await directory.close();
-  }
-}
-async function writeScaffoldFiles(out, files, force, options = {}) {
-  const entries = Object.entries(files).map(([name, body]) => ({
-    body,
-    destination: join(out, name),
-    temporary: join(out, `.${name}.kaji-${randomUUID()}.tmp`)
-  }));
-  const committed = [];
-  const backups = [];
-  const published = [];
-  let backupDirectory;
-  try {
-    throwIfCancelled(options.signal);
-    for (const entry of entries) {
-      await writeFile(entry.temporary, entry.body, { encoding: "utf8", flag: "wx" });
-      throwIfCancelled(options.signal);
-    }
-    if (entries.some(({ destination }) => destinationKind(destination) === "symlink")) {
-      throw new Error("unsafe scaffold destination: symbolic links are not allowed");
-    }
-    if (!force && entries.some(({ destination }) => destinationKind(destination) !== "missing")) {
-      throw Object.assign(new Error("scaffold destination appeared during write"), {
-        code: "EEXIST"
-      });
-    }
-    if (force) {
-      const kinds = entries.map((entry) => [entry, destinationKind(entry.destination)]);
-      if (kinds.some(([, kind]) => kind === "symlink")) {
-        throw new Error("unsafe scaffold destination: symbolic links are not allowed");
-      }
-      if (kinds.some(([, kind]) => kind === "other")) {
-        throw new Error("unsafe scaffold destination: generated paths must be regular files");
-      }
-      backupDirectory = await mkdtemp(join(out, ".kaji-scaffold-backup-"));
-      for (const [entry] of kinds) {
-        const currentKind = destinationKind(entry.destination);
-        if (currentKind === "symlink" || currentKind === "other") {
-          throw new Error("unsafe scaffold destination: generated paths must be regular files");
-        }
-        if (currentKind === "missing") continue;
-        const sourceStat = await lstatAsync(entry.destination, { bigint: true });
-        if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
-          throw new Error("unsafe scaffold destination: generated paths must be regular files");
-        }
-        const backup = join(backupDirectory, basename(entry.destination));
-        await rename(entry.destination, backup);
-        backups.push({ destination: entry.destination, backup });
-        throwIfCancelled(options.signal);
-        const backupStat = await lstatAsync(backup, { bigint: true });
-        throwIfCancelled(options.signal);
-        if (!backupStat.isFile() || backupStat.isSymbolicLink() || backupStat.dev !== sourceStat.dev || backupStat.ino !== sourceStat.ino) {
-          throw new Error("unsafe scaffold destination: destination changed during backup");
-        }
-      }
-      await options.beforePublish?.();
-      throwIfCancelled(options.signal);
-      const publish = options.publish ?? rename;
-      for (const entry of entries) {
-        const temporaryStat = await lstatAsync(entry.temporary, { bigint: true });
-        throwIfCancelled(options.signal);
-        published.push({
-          destination: entry.destination,
-          dev: temporaryStat.dev,
-          ino: temporaryStat.ino
-        });
-        await publish(entry.temporary, entry.destination);
-        throwIfCancelled(options.signal);
-        const destinationStat = await lstatAsync(entry.destination, { bigint: true });
-        throwIfCancelled(options.signal);
-        if (!destinationStat.isFile() || destinationStat.isSymbolicLink() || destinationStat.dev !== temporaryStat.dev || destinationStat.ino !== temporaryStat.ino) {
-          throw new Error("unsafe scaffold destination: destination changed during publication");
-        }
-      }
-      await options.verifyTarget?.();
-      throwIfCancelled(options.signal);
-      await rm(backupDirectory, { recursive: true, force: true });
-      backupDirectory = void 0;
-    } else {
-      await options.beforePublish?.();
-      throwIfCancelled(options.signal);
-      for (const entry of entries) {
-        const sourceStat = await lstatAsync(entry.temporary, { bigint: true });
-        throwIfCancelled(options.signal);
-        await link(entry.temporary, entry.destination);
-        committed.push({
-          destination: entry.destination,
-          dev: sourceStat.dev,
-          ino: sourceStat.ino
-        });
-        throwIfCancelled(options.signal);
-      }
-      await options.verifyTarget?.();
-      throwIfCancelled(options.signal);
-    }
-  } catch (error) {
-    const rollbackErrors = [];
-    if (force) {
-      for (const item of published.reverse()) {
-        try {
-          if (destinationKind(item.destination) === "missing") continue;
-          const destinationStat = await lstatAsync(item.destination, { bigint: true });
-          if (!destinationStat.isFile() || destinationStat.isSymbolicLink() || destinationStat.dev !== item.dev || destinationStat.ino !== item.ino) {
-            throw new Error("scaffold destination changed during rollback");
-          }
-          await rm(item.destination, { force: true });
-        } catch (rollbackError) {
-          rollbackErrors.push(rollbackError);
-        }
-      }
-      for (const item of backups.reverse()) {
-        try {
-          if (destinationKind(item.destination) !== "missing") {
-            throw new Error("scaffold destination changed before backup restore");
-          }
-          await rename(item.backup, item.destination);
-        } catch (rollbackError) {
-          rollbackErrors.push(rollbackError);
-        }
-      }
-      if (rollbackErrors.length === 0 && backupDirectory !== void 0) {
-        try {
-          await rm(backupDirectory, { recursive: true, force: true });
-          backupDirectory = void 0;
-        } catch (rollbackError) {
-          rollbackErrors.push(rollbackError);
-        }
-      }
-    } else {
-      for (const item of committed) {
-        try {
-          const destinationStat = await lstatAsync(item.destination, { bigint: true });
-          if (destinationStat.isFile() && !destinationStat.isSymbolicLink() && destinationStat.dev === item.dev && destinationStat.ino === item.ino) {
-            await rm(item.destination, { force: true });
-          }
-        } catch (cleanupError) {
-          if (cleanupError.code !== "ENOENT") {
-            rollbackErrors.push(cleanupError);
-          }
-        }
-      }
-    }
-    if (rollbackErrors.length > 0) {
-      if (backupDirectory !== void 0) {
-        throw new ScaffoldRollbackError(
-          basename(backupDirectory),
-          new AggregateError([error, ...rollbackErrors])
-        );
-      }
-      throw new AggregateError([error, ...rollbackErrors], "scaffold publication rollback failed");
-    }
-    throw error;
-  } finally {
-    for (const entry of entries) await rm(entry.temporary, { force: true }).catch(() => void 0);
-  }
-}
-async function init(rest, opts) {
-  const log = opts.log ?? ((message) => console.log(message));
-  const err = opts.err ?? ((message) => console.error(message));
-  let args;
-  try {
-    args = parseArgs(rest);
-  } catch (error) {
-    if (error instanceof CliArgError) {
-      err(`Error: ${error.message}`);
-      err("usage: kaji init [path] [--provider mock|openai|anthropic] [--yes] [--force]");
-      return 2;
-    }
-    throw error;
-  }
-  let files;
-  try {
-    files = scaffoldFiles(args.provider);
-  } catch {
-    err("kaji init could not read installed package metadata");
-    return 1;
-  }
-  const destinations = Object.keys(files).map((name) => join(args.out, name));
-  const targetKind = destinationKind(args.out);
-  const kinds = destinations.map((path) => [path, destinationKind(path)]);
-  if (targetKind === "symlink" || kinds.some(([, kind]) => kind === "symlink")) {
-    err("unsafe scaffold destination: symbolic links are not allowed");
-    return 1;
-  }
-  const conflicts = kinds.filter(([, kind]) => kind !== "missing").map(([path]) => path);
-  if (conflicts.length > 0 && !args.force) {
-    err(
-      `refusing to overwrite without --force: ${conflicts.map((path) => path.split("/").at(-1)).join(", ")}`
-    );
-    return 1;
-  }
-  try {
-    if (!existsSync(args.out)) mkdirSync(args.out, { recursive: true });
-    await (opts.initWorkerRunner ?? runPinnedInitWorker)(args.out, files, args.force);
-    for (const name of Object.keys(files)) log(`wrote ${join(args.out, name)}`);
-  } catch (error) {
-    if (error instanceof ScaffoldRollbackError) {
-      err(
-        `kaji init failed while writing the scaffold; original preserved in target directory as ${error.recoveryDirectory}`
-      );
-    } else if (error instanceof Error && error.message.includes("unsafe scaffold destination")) {
-      err(error.message);
-    } else if (error.code === "EEXIST") {
-      err("refusing to overwrite without --force: destination changed during write");
-    } else {
-      err("kaji init failed while writing the scaffold");
-    }
-    return 1;
-  }
-  log("");
-  log(`Next: cd ${args.out} && npm install && npm start (or bun install && bun start)`);
-  return 0;
-}
-
-export {
-  scaffoldRecoveryDirectory,
-  runInitWorkerMain,
-  init
-};
-//# sourceMappingURL=chunk-SEBX54TR.js.map