@kitman-sh/cli 0.9.0 → 0.10.53

package/dist/chunk-pp1p3g6e.js

@@ -0,0 +1,133 @@
+// @bun
+import {
+  isObject2,
+  isSuccess2,
+  decodeUnknownExit,
+  optionalKey,
+  toType,
+  Literal,
+  Unknown,
+  String4,
+  Struct,
+  Record,
+  ArraySchema,
+  Union,
+  makeFilter,
+  isPattern,
+  Finite,
+  isMinLength,
+  isMaxLength,
+  FiniteFromString
+} from "./chunk-mbctzx7e.js";
+
+// packages/core/src/schema.ts
+var Days = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+var DatePattern = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+var TimePattern = /^(\d\d):(\d\d):(\d\d)(?:\.\d+)?(?:([Zz])|([+-])(\d\d):(\d\d))$/;
+function isRfc3339Date(value) {
+  const match = DatePattern.exec(value);
+  if (match === null)
+    return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && leap ? 29 : Days[month] ?? 0);
+}
+function isRfc3339Time(value) {
+  const match = TimePattern.exec(value);
+  if (match === null)
+    return false;
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  const second = Number(match[3]);
+  if (hour > 23 || minute > 59 || second > 60)
+    return false;
+  if (match[5] !== undefined && (Number(match[6]) > 23 || Number(match[7]) > 59))
+    return false;
+  if (second < 60)
+    return true;
+  const sign = match[5] === "-" ? -1 : 1;
+  const utcMinutes = hour * 60 + minute - sign * (Number(match[6] ?? 0) * 60 + Number(match[7] ?? 0));
+  return (utcMinutes % 1440 + 1440) % 1440 === 1439;
+}
+var isDateTime = makeFilter((value) => {
+  const parts = value.split(/T/i);
+  return parts.length === 2 && isRfc3339Date(parts[0] ?? "") && isRfc3339Time(parts[1] ?? "");
+}, { expected: "an RFC 3339 date-time", toJsonSchema: () => ({ format: "date-time" }) });
+var Numeric = Union([Finite, FiniteFromString]);
+var isWholeNumber = makeFilter(Number.isInteger, {
+  expected: "an integer",
+  toJsonSchema: () => ({ multipleOf: 1 })
+});
+function guard(schema) {
+  const cached = guards.get(schema);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const decode = decodeUnknownExit(toType(schema));
+  const created = (input) => isSuccess2(decode(input, { onExcessProperty: "error" })) || hasUndefinedProperty(input) && isSuccess2(decode(withoutUndefined(input), { onExcessProperty: "error" }));
+  guards.set(schema, created);
+  return created;
+}
+var guards = new WeakMap;
+function hasUndefinedProperty(value) {
+  if (Array.isArray(value))
+    return value.some(hasUndefinedProperty);
+  if (!isObject2(value))
+    return false;
+  return Object.values(value).some((entry) => entry === undefined || hasUndefinedProperty(entry));
+}
+function withoutUndefined(value) {
+  if (Array.isArray(value)) {
+    return value.map(withoutUndefined);
+  }
+  if (!isObject2(value) || Object.getPrototypeOf(value) !== Object.prototype)
+    return value;
+  return Object.fromEntries(Object.entries(value).flatMap(([key, entry]) => entry === undefined ? [] : [[key, withoutUndefined(entry)]]));
+}
+
+// packages/core/src/common.ts
+var Id = String4.check(isMinLength(1));
+var Slug = String4.check(isMinLength(1), isPattern(new RegExp("^[a-z0-9]+(?:-[a-z0-9]+)*$", "u")));
+var Timestamp = String4.check(isDateTime);
+var ApiError = Struct({
+  error: Struct({
+    code: String4,
+    message: String4,
+    details: optionalKey(Record(String4, Unknown))
+  })
+});
+var ActorType = Union([
+  Literal("human"),
+  Literal("delegated_agent"),
+  Literal("agent")
+]);
+
+// packages/core/src/secret.ts
+var SecretName = String4.check(isPattern(new RegExp("^[A-Za-z_][A-Za-z0-9_]*$", "u")), isMinLength(1), isMaxLength(128));
+var SecretScope = Union([Literal("workspace"), Literal("team")]);
+var SecretHost = String4.check(isPattern(new RegExp("^(\\*\\.)?[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*(?::[0-9]{1,5})?$", "u")), isMaxLength(260));
+var SecretHosts = ArraySchema(SecretHost).check(isMaxLength(32));
+var secretReference = (owner, name) => `secret://${owner}/${name}`;
+var referencePattern = /secret:\/\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+/g;
+var replaceSecretReferences = (text, swap) => text.replace(referencePattern, swap);
+var secretReferencesIn = (text) => [...new Set(text.match(referencePattern) ?? [])];
+var SecretSummary = Struct({
+  name: SecretName,
+  scope: SecretScope,
+  teamId: optionalKey(Id),
+  hosts: SecretHosts,
+  setByActorType: ActorType,
+  setByActorId: String4,
+  setAt: Timestamp
+});
+var SecretList = Struct({ items: ArraySchema(SecretSummary) });
+var SecretSet = Struct({
+  value: String4.check(isMinLength(1), isMaxLength(65536)),
+  teamId: optionalKey(String4.check(isMinLength(1))),
+  hosts: optionalKey(SecretHosts)
+});
+var SecretScopeQuery = Struct({ teamId: optionalKey(Id) });
+
+export { isDateTime, Numeric, isWholeNumber, guard, Id, Timestamp, ActorType, SecretName, SecretScope, SecretHosts, secretReference, replaceSecretReferences, secretReferencesIn };

package/dist/chunk-r8p3nxcp.js

@@ -0,0 +1,231 @@
+// @bun
+import {
+  isObject2,
+  isUint8Array,
+  isSuccess,
+  TaggedError,
+  succeed6,
+  gen,
+  flatMap3,
+  andThen2,
+  catchReason,
+  orElseSucceed,
+  decodeJsonString,
+  encodePrettyJsonString
+} from "./chunk-mbctzx7e.js";
+import {
+  isJsonObject
+} from "./chunk-arvwar2c.js";
+import {
+  FileSystem,
+  Path
+} from "./chunk-11p4wf6n.js";
+import {
+  tomlTableHeader2,
+  tomlKeyPath2,
+  isPathWithin2
+} from "./chunk-7thnf14y.js";
+import {
+  instructionsStart,
+  instructionsEnd,
+  renderMcpServer,
+  materializeKitSetup,
+  tomlInline
+} from "./chunk-wh1pa2aa.js";
+import"./chunk-pp1p3g6e.js";
+import"./chunk-g5bs3f6z.js";
+import"./chunk-3bj7sc3v.js";
+import"./chunk-z821b2gp.js";
+
+// packages/agent-runtime/src/kit-setup-sync.ts
+class KitSyncError extends TaggedError("KitSyncError") {
+}
+var layoutOf = (path, harness, home) => {
+  switch (harness) {
+    case "claude":
+      return {
+        root: home,
+        instructions: path.join(home, ".claude/CLAUDE.md"),
+        marketplace: path.join(home, ".claude/kitman-marketplace"),
+        mcp: { file: path.join(home, ".claude.json"), key: "mcpServers" }
+      };
+    case "codex":
+      return {
+        root: path.join(home, ".codex"),
+        instructions: path.join(home, ".codex/AGENTS.md"),
+        marketplace: path.join(home, ".codex/codex-marketplace")
+      };
+    case "pi":
+      return {
+        root: path.join(home, ".pi/agent"),
+        instructions: path.join(home, ".pi/agent/AGENTS.md"),
+        mcp: { file: path.join(home, ".pi/agent/mcp.json"), key: "mcpServers" }
+      };
+    case "opencode":
+      return {
+        root: path.join(home, ".config/opencode"),
+        instructions: path.join(home, ".config/opencode/AGENTS.md"),
+        mcp: { file: path.join(home, ".config/opencode/opencode.json"), key: "mcp" }
+      };
+  }
+};
+var codexBlockStart = "# >>> kitman sync: replaced on every sync";
+var codexBlockEnd = "# <<< kitman sync";
+var retiredInstructions = [
+  "<!-- KITMAN_AGENT_ENVIRONMENT_START -->",
+  "<!-- KITMAN_AGENT_ENVIRONMENT_END -->"
+];
+var withoutBlock = (text, start, end) => {
+  const from = text.indexOf(start);
+  const to = text.indexOf(end, from);
+  return from === -1 || to === -1 ? text : `${text.slice(0, from).trimEnd()}
+
+${text.slice(to + end.length).trimStart()}`;
+};
+var objectAt = (value, key) => {
+  const entry = value[key];
+  return isJsonObject(entry) ? entry : {};
+};
+var withEntries = (value, key, entries) => {
+  const { [key]: _replaced, ...rest } = value;
+  return Object.keys(entries).length === 0 ? rest : { ...rest, [key]: entries };
+};
+var tomlKey = (key) => /^[A-Za-z0-9_-]+$/u.test(key) ? key : JSON.stringify(key);
+var tomlTable = (header, value) => [
+  header,
+  ...isObject2(value) && !Array.isArray(value) ? Object.entries(value).map(([key, entry]) => `${tomlKey(key)} = ${tomlInline(entry)}`) : [],
+  ""
+];
+var codexConfigKept = (text, servers) => {
+  const kept = [];
+  let inBlock = false;
+  let dropping = false;
+  for (const line of text.split(`
+`)) {
+    if (line === codexBlockStart)
+      inBlock = true;
+    if (inBlock) {
+      inBlock = line !== codexBlockEnd;
+      continue;
+    }
+    const header = tomlTableHeader2(line);
+    if (header !== undefined) {
+      const [table, name] = tomlKeyPath2(header);
+      dropping = table === "mcp_servers" && name !== undefined && servers.has(name) || table === "marketplaces" && name === "kitman" || table === "plugins" && name?.endsWith("@kitman") === true;
+    }
+    if (!dropping)
+      kept.push(line);
+  }
+  return kept.join(`
+`).trim();
+};
+var syncKitSetup = (input) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const setup = materializeKitSetup(input.harness, input.kits);
+  const layout = layoutOf(path, input.harness, input.home);
+  const skillsDir = path.join(layout.root, setup.skillsRoot);
+  const write = (file, content) => andThen2(fs.makeDirectory(path.dirname(file), { recursive: true }), isUint8Array(content) ? fs.writeFile(file, content) : fs.writeFileString(file, content));
+  const readText = (file) => fs.readFileString(file).pipe(catchReason("PlatformError", "NotFound", () => succeed6("")));
+  const readJson = (file) => gen(function* () {
+    const text = yield* readText(file);
+    const value = yield* decodeJsonString(text.trim() === "" ? "{}" : text).pipe(orElseSucceed(() => {
+      return;
+    }));
+    if (!isJsonObject(value))
+      return yield* new KitSyncError({ message: `${file} is not a JSON object; fix or move it, then sync again` });
+    return value;
+  });
+  const writeJson = (file, value) => flatMap3(encodePrettyJsonString(value), (json) => write(file, `${json}
+`));
+  const targets = Object.entries(setup.files).flatMap(([file, content]) => {
+    if (file === setup.instructions?.path || file === ".mcp.json")
+      return [];
+    const target = input.harness === "claude" && file.startsWith("plugins/") && layout.marketplace !== undefined ? path.join(layout.marketplace, file) : path.join(layout.root, file);
+    return [{ file, target, content }];
+  });
+  const astray = targets.find(({ target }) => !isPathWithin2(path, skillsDir, target) && (layout.marketplace === undefined || !isPathWithin2(path, layout.marketplace, target)));
+  if (astray !== undefined)
+    return yield* new KitSyncError({ message: `A Kit's file ${astray.file} would land outside its directory` });
+  const skills = [...new Set([...input.previous?.skills ?? [], ...setup.skills])];
+  const outside = skills.find((skill) => path.dirname(path.join(skillsDir, skill)) !== skillsDir);
+  if (outside !== undefined)
+    return yield* new KitSyncError({ message: `A Kit's skill name ${outside} would land outside its directory` });
+  for (const skill of skills)
+    yield* fs.remove(path.join(skillsDir, skill), { recursive: true, force: true });
+  if (layout.marketplace !== undefined)
+    yield* fs.remove(layout.marketplace, { recursive: true, force: true });
+  for (const { target, content } of targets)
+    yield* write(target, content);
+  if (input.harness === "claude" && layout.marketplace !== undefined && setup.plugins.length > 0)
+    yield* writeJson(path.join(layout.marketplace, ".claude-plugin/marketplace.json"), {
+      name: "kitman",
+      owner: { name: "Kitman" },
+      plugins: setup.plugins.map((name) => ({ name, source: `./plugins/${name}` }))
+    });
+  const instructions = withoutBlock(withoutBlock(yield* readText(layout.instructions), instructionsStart, instructionsEnd), ...retiredInstructions).trim();
+  if (setup.instructions !== undefined)
+    yield* write(layout.instructions, instructions === "" ? setup.instructions.content : `${instructions}
+
+${setup.instructions.content}`);
+  else if (instructions === "")
+    yield* fs.remove(layout.instructions, { force: true });
+  else
+    yield* write(layout.instructions, `${instructions}
+`);
+  const kitman = renderMcpServer(input.harness, {
+    kind: "stdio",
+    command: input.kitman.command,
+    args: [...input.kitman.args]
+  });
+  const servers = {
+    ...isSuccess(kitman) ? { kitman: kitman.success } : undefined,
+    ...setup.mcpConfig
+  };
+  const replaced = new Set(["kitman", ...input.previous?.mcpServers ?? [], ...Object.keys(servers)]);
+  if (layout.mcp !== undefined) {
+    const { file, key } = layout.mcp;
+    const config = yield* readJson(file);
+    const kept = Object.fromEntries(Object.entries(objectAt(config, key)).filter(([name]) => !replaced.has(name)));
+    yield* writeJson(file, withEntries(config, key, Object.fromEntries([...Object.entries(kept), ...Object.entries(servers)])));
+  }
+  if (input.harness === "codex") {
+    const file = path.join(layout.root, "config.toml");
+    const kept = codexConfigKept(yield* readText(file), replaced);
+    const block = [
+      codexBlockStart,
+      ...Object.entries(servers).flatMap(([name, server]) => tomlTable(`[mcp_servers.${tomlKey(name)}]`, server)),
+      ...setup.plugins.length === 0 || layout.marketplace === undefined ? [] : [
+        ...tomlTable("[marketplaces.kitman]", { source_type: "local", source: layout.marketplace }),
+        ...setup.plugins.flatMap((plugin) => tomlTable(`[plugins.${tomlKey(`${plugin}@kitman`)}]`, { enabled: true }))
+      ],
+      ...setup.skills.flatMap((skill) => tomlTable("[[skills.config]]", { path: path.join(skillsDir, skill, "SKILL.md"), enabled: true })),
+      codexBlockEnd,
+      ""
+    ].join(`
+`);
+    yield* write(file, kept === "" ? block : `${kept}
+
+${block}`);
+  }
+  if (input.harness === "claude" && layout.marketplace !== undefined) {
+    const file = path.join(input.home, ".claude/settings.json");
+    const settings = yield* readJson(file);
+    const { kitman: _kitman, ...marketplaces } = objectAt(settings, "extraKnownMarketplaces");
+    const enabled = Object.fromEntries(Object.entries(objectAt(settings, "enabledPlugins")).filter(([plugin]) => !plugin.endsWith("@kitman")));
+    const next = withEntries(withEntries(settings, "extraKnownMarketplaces", {
+      ...marketplaces,
+      ...setup.plugins.length === 0 ? undefined : { kitman: { source: { source: "directory", path: layout.marketplace } } }
+    }), "enabledPlugins", { ...enabled, ...Object.fromEntries(setup.plugins.map((plugin) => [`${plugin}@kitman`, true])) });
+    if (Object.keys(next).length > 0 || Object.keys(settings).length > 0)
+      yield* writeJson(file, next);
+  }
+  return {
+    synced: { skills: setup.skills, mcpServers: Object.keys(setup.mcpConfig) },
+    unsupported: setup.unsupported
+  };
+});
+export {
+  KitSyncError,
+  syncKitSetup
+};