@kitman-sh/cli 0.0.0-stage → 0.6.0

package/dist/chunk-fc0v325q.js

@@ -0,0 +1,75 @@
+// @bun
+import {
+  TaggedError,
+  tryPromise,
+  is,
+  encodeEffect,
+  optionalKey,
+  String2,
+  Record,
+  ArraySchema,
+  Union,
+  TaggedStruct,
+  fromJsonString,
+  TaggedError2,
+  toCodecJson,
+  Json,
+  guard,
+  ProgramWorkUnit
+} from "./chunk-txyq8r41.js";
+import {
+  LoopManifest
+} from "./chunk-hrvcz0m4.js";
+import {
+  ManifestInvalid,
+  make,
+  Suspended,
+  LoopCheckError
+} from "./chunk-n32jhswz.js";
+import {
+  RunnerRpcError
+} from "./chunk-xdk488qp.js";
+
+// packages/sdk/src/program/engine.ts
+class JournalWriteFailed extends TaggedError("JournalWriteFailed") {
+  get message() {
+    return `Journal write failed: ${this.cause.message}`;
+  }
+}
+var JournalEntries = Record(String2, Json);
+var isSuspended = is(Suspended);
+var emptyWorkflow = make("kitman-loop/none", { payload: {}, idempotencyKey: () => "none" });
+var replayStatuses = new Set([401, 403, 409, 429]);
+var isRunnerRpcError = is(RunnerRpcError);
+var programLease = (work) => ({
+  workUnitId: work.id,
+  leaseOwnerId: work.lease.leaseOwnerId,
+  runnerReplicaId: work.lease.runnerReplicaId,
+  leaseId: work.lease.leaseId,
+  attempt: work.lease.attempt,
+  fencingToken: work.lease.fencingToken,
+  capacitySlot: work.lease.capacitySlot
+});
+
+// packages/sdk/src/program/host.ts
+var describeFlag = "--kitman-describe";
+var Described = Union([
+  TaggedStruct("Described", {
+    loops: ArraySchema(LoopManifest),
+    agents: Record(String2, Json),
+    schedules: optionalKey(Record(String2, Json)),
+    kits: optionalKey(Record(String2, Json))
+  }),
+  TaggedStruct("Refused", { error: Union([ManifestInvalid, LoopCheckError]) })
+]);
+var encodeDescribed = encodeEffect(fromJsonString(toCodecJson(Described)));
+
+class ProgramRefused extends TaggedError2()("ProgramRefused", { reason: String2 }) {
+  get message() {
+    return this.reason;
+  }
+}
+var readStdin = tryPromise(() => Bun.stdin.text());
+var isWorkUnit = guard(ProgramWorkUnit);
+
+export { programLease, describeFlag, Described };

package/dist/chunk-h8ctzn91.js

@@ -0,0 +1,241 @@
+// @bun
+import {
+  isString,
+  isTagged,
+  all,
+  forEach,
+  succeed5,
+  gen,
+  fail4,
+  try_,
+  flatMap,
+  map3,
+  catchTags,
+  mapError,
+  ignore,
+  orElseSucceed,
+  scoped,
+  acquireRelease,
+  decodeText,
+  mkString,
+  FileSystem,
+  Path,
+  ChildProcessSpawner,
+  make15,
+  decodeUnknownEffect,
+  decodeEffect,
+  optionalKey,
+  Literal,
+  String2,
+  Struct,
+  Record,
+  ArraySchema,
+  Union,
+  Literals,
+  fromJsonString,
+  TaggedError2,
+  toCodecJson,
+  digestSha256
+} from "./chunk-txyq8r41.js";
+import {
+  AgentDeclaration,
+  KitInstallationDeclaration,
+  KitAssignmentDeclaration,
+  PackageDeclarations
+} from "./chunk-hrvcz0m4.js";
+import"./chunk-hw7qkap1.js";
+import {
+  RunnerRpcProtocolVersion
+} from "./chunk-xdk488qp.js";
+import"./chunk-n32jhswz.js";
+import {
+  describeFlag,
+  Described
+} from "./chunk-fc0v325q.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(make15(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
+};

package/dist/chunk-hrvcz0m4.js

@@ -0,0 +1,211 @@
+// @bun
+import {
+  declare,
+  optionalKey,
+  Literal,
+  Null,
+  String2,
+  Boolean2,
+  Struct,
+  Record,
+  ArraySchema,
+  Union,
+  Literals,
+  makeFilter,
+  isPattern,
+  Finite,
+  isGreaterThanOrEqualTo,
+  isLessThanOrEqualTo2,
+  Int,
+  isMinLength,
+  isMaxLength,
+  toEquivalence,
+  Json,
+  guard,
+  relativePathPattern,
+  skillNamePattern,
+  SafeJson,
+  AgentEfforts,
+  LoopDataSchemaRef,
+  KitKinds
+} from "./chunk-txyq8r41.js";
+
+// packages/core/src/schedule.ts
+var ScheduleFrequency = ["daily", "weekly"];
+var ScheduleMisfirePolicies = ["skip", "fire_once", "catch_up"];
+var ScheduleOverlapPolicies = ["allow", "skip", "coalesce"];
+var ScheduleVersionStatuses = ["draft", "published", "disabled", "archived"];
+var ScheduleCalendarRule = Struct({
+  frequency: Literals(ScheduleFrequency),
+  hour: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(23)),
+  minute: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(59)),
+  second: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(59))),
+  daysOfWeek: optionalKey(ArraySchema(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(6))).check(isMinLength(1), isMaxLength(7)))
+});
+var ScheduleCronRule = Struct({
+  cron: String2.check(isMinLength(9), isMaxLength(200), isPattern(new RegExp("^[0-9*,/-]+( [0-9*,/-]+){4}$", "u")))
+});
+var ScheduleRule = Union([ScheduleCalendarRule, ScheduleCronRule]);
+var cronBounds = [
+  [0, 59],
+  [0, 23],
+  [1, 31],
+  [1, 12],
+  [0, 7]
+];
+function cronField(field, [min, max]) {
+  const values = new Set;
+  for (const part of field.split(",")) {
+    const match = /^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/.exec(part);
+    if (match === null)
+      return;
+    const from = match[1] === "*" ? min : Number(match[2]);
+    const to = match[1] === "*" ? max : match[3] === undefined ? match[4] === undefined ? from : max : Number(match[3]);
+    const step = match[4] === undefined ? 1 : Number(match[4]);
+    if (from < min || to > max || from > to || step < 1)
+      return;
+    for (let value = from;value <= to; value += step)
+      values.add(value);
+  }
+  return values;
+}
+function parseCron(cron) {
+  const fields = cron.split(" ");
+  const [minutes, hours, days, months, weekdays] = fields.map((field, index) => cronField(field, cronBounds[index] ?? [0, 0]));
+  if (fields.length !== 5 || !minutes || !hours || !days || !months || !weekdays)
+    return;
+  return {
+    minutes,
+    hours,
+    days,
+    months,
+    weekdays: new Set([...weekdays].map((value) => value % 7)),
+    dayRestricted: !(fields[2] ?? "").startsWith("*"),
+    weekdayRestricted: !(fields[4] ?? "").startsWith("*")
+  };
+}
+function isScheduleRule(value) {
+  return guard(ScheduleRule)(value) && (!("cron" in value) || parseCron(value.cron) !== undefined);
+}
+var ScheduleVersion = Struct({
+  contractVersion: Literal("schedule.v1"),
+  id: String2.check(isMinLength(1)),
+  scheduleId: String2.check(isMinLength(1)),
+  workspaceId: String2.check(isMinLength(1)),
+  projectId: optionalKey(String2.check(isMinLength(1))),
+  loopId: optionalKey(String2.check(isMinLength(1))),
+  name: optionalKey(String2.check(isMinLength(1), isMaxLength(200))),
+  version: Int.check(isGreaterThanOrEqualTo(1)),
+  status: Literals(ScheduleVersionStatuses),
+  timezone: String2.check(isMinLength(1), isMaxLength(80)),
+  rule: ScheduleRule,
+  misfirePolicy: Literals(ScheduleMisfirePolicies),
+  overlapPolicy: Literals(ScheduleOverlapPolicies),
+  maxCatchUp: Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(200)),
+  misfireGraceSeconds: optionalKey(Int.check(isGreaterThanOrEqualTo(0), isLessThanOrEqualTo2(604800))),
+  inputSchemaRef: optionalKey(LoopDataSchemaRef),
+  input: optionalKey(SafeJson),
+  createdAt: String2.check(isMinLength(1))
+});
+var zones = new Map;
+var resolvedLocalDateTimes = new Map;
+
+// packages/core/src/package-declarations.ts
+var LoopCapabilities = [
+  "agent_work",
+  "ask",
+  "call",
+  "verify",
+  "change_request",
+  "write_back",
+  "post_comment",
+  "create_tasks",
+  "merge_change_request",
+  "publish_release"
+];
+var JsonObject = Record(String2, Json);
+var recordKeyedBy = (pattern, value) => Record(String2, value).check(makeFilter((record) => {
+  const bad = Object.keys(record).find((key) => !new RegExp(pattern).test(key));
+  return bad === undefined ? true : `${JSON.stringify(bad)} is not a valid name or relative path`;
+}));
+var SecretName = String2.check(isPattern(/^[A-Za-z_][A-Za-z0-9_]{0,127}$/));
+var EventFilterValue = Union([String2, Finite, Boolean2, Null]);
+var LoopManifest = Struct({
+  id: String2,
+  title: String2,
+  input: JsonObject,
+  output: JsonObject,
+  outcome: optionalKey(Literals(["feature", "bug", "refactor", "investigation", "docs", "migration"])),
+  agents: Record(String2, String2),
+  checkout: Literals(["none", "read", "write"]),
+  when: ArraySchema(Struct({
+    event: String2,
+    filter: optionalKey(Record(String2, Union([EventFilterValue, ArraySchema(EventFilterValue)]))),
+    input: Record(String2, String2)
+  })),
+  offers: ArraySchema(Struct({ id: String2, title: String2, loop: String2 })),
+  capabilities: ArraySchema(Literals(LoopCapabilities)),
+  secrets: optionalKey(ArraySchema(SecretName))
+});
+var AgentDeclaration = Struct({
+  extends: optionalKey(String2),
+  instructions: optionalKey(String2),
+  harness: optionalKey(String2),
+  model: optionalKey(String2),
+  effort: optionalKey(Literals(AgentEfforts)),
+  kits: optionalKey(ArraySchema(String2)),
+  network: optionalKey(Union([Struct({ hosts: ArraySchema(String2) }), Literal("open")])),
+  sandbox: optionalKey(Literal("docker"))
+});
+var scheduleFields = {
+  name: String2.check(isMinLength(1)),
+  loop: String2,
+  project: optionalKey(String2),
+  input: optionalKey(JsonObject),
+  timezone: String2,
+  misfire: optionalKey(Literals(ScheduleMisfirePolicies)),
+  overlap: optionalKey(Literals(ScheduleOverlapPolicies))
+};
+var ScheduleDeclaration = Union([
+  Struct({
+    ...scheduleFields,
+    cron: String2.check(makeFilter((cron) => isScheduleRule({ cron }) || "five cron fields, each within its range"))
+  }),
+  Struct({
+    ...scheduleFields,
+    rule: declare((value) => isScheduleRule(value), {
+      expected: "a Schedule rule: frequency daily or weekly, hour, minute, and optionally second and daysOfWeek"
+    })
+  })
+]);
+var AuthoredKitDeclaration = Struct({
+  name: String2.check(isMinLength(1)),
+  kind: optionalKey(Literals(KitKinds)),
+  description: optionalKey(String2),
+  context: String2,
+  skills: optionalKey(recordKeyedBy(skillNamePattern, recordKeyedBy(relativePathPattern, String2)))
+});
+var KitInstallationDeclaration = Struct({
+  source: String2.check(isMinLength(1)),
+  version: optionalKey(String2)
+});
+var KitAssignmentDeclaration = Struct({
+  kit: String2.check(isMinLength(1)),
+  workspace: optionalKey(Literals(["default", "mandatory"])),
+  projects: optionalKey(ArraySchema(String2))
+});
+var KitDeclaration = Union([
+  KitInstallationDeclaration,
+  KitAssignmentDeclaration,
+  AuthoredKitDeclaration
+]);
+var PackageDeclarations = Struct({
+  loops: ArraySchema(LoopManifest),
+  agents: Record(String2, AgentDeclaration),
+  schedules: optionalKey(Record(String2, ScheduleDeclaration)),
+  kits: optionalKey(Record(String2, KitDeclaration))
+});
+var sameLoop = toEquivalence(LoopManifest);
+var sameAgent = toEquivalence(AgentDeclaration);
+
+export { LoopCapabilities, LoopManifest, AgentDeclaration, KitInstallationDeclaration, KitAssignmentDeclaration, PackageDeclarations };