@kitman-sh/cli 0.0.0-stage → 0.7.0

package/dist/chunk-gzhxsb25.js

@@ -0,0 +1,13 @@
+// @bun
+import {
+  runnerWebSocketProtocol2,
+  runnerRpcUrl2,
+  makeRunnerRpcClient2
+} from "./chunk-ae7gx971.js";
+import"./chunk-dwgta18y.js";
+import"./chunk-704ws2q7.js";
+export {
+  makeRunnerRpcClient2 as makeRunnerRpcClient,
+  runnerRpcUrl2 as runnerRpcUrl,
+  runnerWebSocketProtocol2 as runnerWebSocketProtocol
+};

package/dist/chunk-hrd7xmax.js

@@ -0,0 +1,238 @@
+// @bun
+import {
+  isString,
+  isTagged,
+  all,
+  forEach,
+  succeed5,
+  gen,
+  fail4,
+  try_,
+  flatMap,
+  map3,
+  catchTags,
+  mapError,
+  ignore,
+  orElseSucceed,
+  scoped,
+  acquireRelease,
+  decodeText,
+  mkString,
+  FileSystem,
+  Path,
+  ChildProcessSpawner,
+  make11,
+  decodeUnknownEffect,
+  decodeEffect,
+  optionalKey,
+  Literal,
+  String2,
+  Struct,
+  Record,
+  ArraySchema,
+  Union,
+  Literals,
+  fromJsonString,
+  TaggedError2,
+  toCodecJson,
+  digestSha256,
+  AgentDeclaration,
+  KitInstallationDeclaration,
+  KitAssignmentDeclaration,
+  PackageDeclarations,
+  RunnerRpcProtocolVersion
+} from "./chunk-704ws2q7.js";
+import"./chunk-dwgta18y.js";
+import"./chunk-ae7gx971.js";
+import"./chunk-ztmwmk8t.js";
+import {
+  describeFlag,
+  Described
+} from "./chunk-6kdj8psf.js";
+
+// packages/sdk/src/build/index.ts
+class DependencyInstallFailed extends TaggedError2()("DependencyInstallFailed", {
+  reason: String2
+}) {
+  get message() {
+    return `Dependencies do not install from the lockfile: ${this.reason}`;
+  }
+}
+
+class BundleFailed extends TaggedError2()("BundleFailed", { reason: String2 }) {
+  get message() {
+    return `The Package does not bundle: ${this.reason}`;
+  }
+}
+
+class DeclarationsInvalid extends TaggedError2()("DeclarationsInvalid", {
+  reason: String2
+}) {
+  get message() {
+    return `The Package's declarations are invalid: ${this.reason}`;
+  }
+}
+var RepositoryText = Union([String2, Struct({ file: String2 })]);
+var ConfigAgents = Record(String2, Struct({
+  extends: optionalKey(String2),
+  instructions: optionalKey(RepositoryText),
+  harness: optionalKey(String2),
+  model: optionalKey(String2),
+  effort: AgentDeclaration.fields.effort,
+  kits: optionalKey(ArraySchema(String2)),
+  network: optionalKey(Union([Struct({ hosts: ArraySchema(String2) }), Literal("open")])),
+  sandbox: optionalKey(Literal("docker"))
+}));
+var ConfigKits = Record(String2, Union([
+  KitInstallationDeclaration,
+  KitAssignmentDeclaration,
+  Struct({
+    name: String2,
+    kind: optionalKey(Literals(["technology", "brand", "domain", "process", "other"])),
+    description: optionalKey(String2),
+    context: RepositoryText,
+    skills: optionalKey(ArraySchema(String2))
+  })
+]));
+var run = (command, args, cwd) => gen(function* () {
+  const spawner = yield* ChildProcessSpawner;
+  const handle = yield* spawner.spawn(make11(command, args, { cwd, stdin: "ignore" }));
+  const [stdout, stderr, exitCode] = yield* all([
+    mkString(decodeText(handle.stdout)),
+    mkString(decodeText(handle.stderr)),
+    handle.exitCode
+  ], { concurrency: 3 });
+  return { stdout, stderr, ok: exitCode === 0 };
+}).pipe(scoped);
+var failure = (result) => (result.stderr.trim() || result.stdout.trim()).slice(-2000);
+var provenance = (directory) => gen(function* () {
+  const git = (...args) => run("git", args, directory).pipe(map3((result) => result.ok ? result.stdout.trim() : undefined), orElseSucceed(() => {
+    return;
+  }));
+  const repository = yield* git("remote", "get-url", "origin");
+  const commit = yield* git("rev-parse", "HEAD");
+  const status = yield* git("status", "--porcelain");
+  return {
+    ...repository ? { repository } : undefined,
+    ...commit ? { commit } : undefined,
+    clean: commit !== undefined && status === ""
+  };
+});
+var inRepository = (directory, file, what) => gen(function* () {
+  const path = yield* Path;
+  const resolved = path.resolve(directory, file);
+  if (path.relative(directory, resolved).startsWith(".."))
+    return yield* new DeclarationsInvalid({ reason: `${what} ${file} is outside the repository` });
+  return resolved;
+});
+var readText = (directory, text, what) => gen(function* () {
+  if (isString(text))
+    return text;
+  const fs = yield* FileSystem;
+  const file = yield* inRepository(directory, text.file, what);
+  return yield* fs.readFileString(file).pipe(mapError(() => new DeclarationsInvalid({ reason: `${what} ${text.file} does not read` })));
+});
+var readAgents = (directory, agents) => forEach(Object.entries(agents), ([id, { instructions, ...agent }]) => instructions === undefined ? succeed5([id, agent]) : map3(readText(directory, instructions, `Agent "${id}" instructions`), (text) => [id, { ...agent, instructions: text.trim() }])).pipe(map3(Object.fromEntries));
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+var readSkill = (directory, skill, what) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const root = yield* inRepository(directory, skill, what);
+  const unreadable = () => new DeclarationsInvalid({ reason: `${what} ${skill} does not read` });
+  const entries = yield* fs.readDirectory(root, { recursive: true }).pipe(mapError(unreadable));
+  const files = {};
+  for (const entry of entries.toSorted()) {
+    const file = path.join(root, entry);
+    if ((yield* fs.stat(file).pipe(mapError(unreadable))).type !== "File")
+      continue;
+    const bytes = yield* fs.readFile(file).pipe(mapError(unreadable));
+    const text = yield* try_({
+      try: () => utf8.decode(bytes),
+      catch: () => new DeclarationsInvalid({ reason: `${what} ${skill} holds a binary file, ${entry}` })
+    });
+    if (text.includes("\x00"))
+      return yield* new DeclarationsInvalid({ reason: `${what} ${skill} holds a binary file, ${entry}` });
+    files[entry.split(path.sep).join("/")] = text;
+  }
+  if (files["SKILL.md"] === undefined)
+    return yield* new DeclarationsInvalid({ reason: `${what} ${skill} has no SKILL.md` });
+  return [path.basename(root), files];
+});
+var readKits = (directory, kits) => forEach(Object.entries(kits), ([key, kit]) => gen(function* () {
+  if (!("context" in kit))
+    return [key, kit];
+  const { context, skills, ...authored } = kit;
+  const what = `Kit "${key}"`;
+  return [
+    key,
+    {
+      ...authored,
+      context: yield* readText(directory, context, `${what} context`),
+      ...skills === undefined ? undefined : {
+        skills: Object.fromEntries(yield* forEach(skills, (skill) => readSkill(directory, skill, `${what} skill`)))
+      }
+    }
+  ];
+})).pipe(map3(Object.fromEntries));
+var PackageJson = fromJsonString(Struct({ name: String2 }));
+var packageName = (root) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  return yield* fs.readFileString(path.join(root, "package.json")).pipe(flatMap(decodeEffect(PackageJson)), map3((manifest) => manifest.name), mapError(() => new DeclarationsInvalid({ reason: "package.json has no name" })));
+});
+var duplicateLoopId = (loops) => loops.map((loop) => loop.id).find((id, index, ids) => ids.indexOf(id) !== index);
+var buildPackage = (directory) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const root = path.resolve(directory);
+  const source = yield* provenance(root);
+  const name = yield* packageName(root);
+  const installed = yield* run("bun", ["install", "--frozen-lockfile", "--ignore-scripts"], root).pipe(mapError((error) => new DependencyInstallFailed({ reason: error.message })));
+  if (!installed.ok)
+    return yield* new DependencyInstallFailed({ reason: failure(installed) });
+  const entry = path.join(root, ".kitman-build-entry.ts");
+  yield* acquireRelease(fs.writeFileString(entry, `import config from './kitman.config.ts'
+import { runPackage } from '@kitman-sh/sdk/program'
+
+runPackage(config)
+`), () => ignore(fs.remove(entry)));
+  const out = yield* fs.makeTempDirectoryScoped({ prefix: "kitman-package-" });
+  const bundleFile = path.join(out, "bundle.js");
+  const bundled = yield* run("bun", ["build", entry, "--target=bun", "--format=esm", "--outfile", bundleFile], root);
+  if (!bundled.ok)
+    return yield* new BundleFailed({ reason: failure(bundled) });
+  const described = yield* run("bun", [bundleFile, describeFlag], out);
+  if (!described.ok)
+    return yield* new BundleFailed({ reason: `the bundle does not load: ${failure(described)}` });
+  const result = yield* decodeEffect(fromJsonString(toCodecJson(Described)))(described.stdout).pipe(mapError((error) => new BundleFailed({ reason: `the bundle described itself wrongly: ${error.message}` })));
+  if (isTagged(result, "Refused"))
+    return yield* result.error;
+  const duplicate = duplicateLoopId(result.loops);
+  if (duplicate !== undefined)
+    return yield* new DeclarationsInvalid({ reason: `Loop "${duplicate}" is declared twice` });
+  const agents = yield* decodeUnknownEffect(ConfigAgents)(result.agents).pipe(mapError((error) => new DeclarationsInvalid({ reason: error.message })));
+  const kits = result.kits === undefined ? undefined : yield* decodeUnknownEffect(ConfigKits)(result.kits).pipe(mapError((error) => new DeclarationsInvalid({ reason: error.message })));
+  const declarations = yield* decodeUnknownEffect(PackageDeclarations)({
+    loops: result.loops,
+    agents: yield* readAgents(root, agents),
+    ...result.schedules === undefined ? undefined : { schedules: result.schedules },
+    ...kits === undefined ? undefined : { kits: yield* readKits(root, kits) }
+  }).pipe(mapError((error) => new DeclarationsInvalid({ reason: error.message })));
+  const bundle = yield* fs.readFile(bundleFile).pipe(mapError((error) => new BundleFailed({ reason: error.message })));
+  return {
+    name,
+    bundle,
+    digest: digestSha256(bundle, "hex"),
+    declarations,
+    protocolVersion: RunnerRpcProtocolVersion,
+    provenance: source
+  };
+}).pipe(scoped, catchTags({
+  PlatformError: (error) => fail4(new BundleFailed({ reason: error.message }))
+}));
+export {
+  BundleFailed,
+  DeclarationsInvalid,
+  DependencyInstallFailed,
+  buildPackage
+};