@cimplify/cli 0.15.3 → 0.16.0

package/dist/chunk-NY4YT7O6.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import { collectSourcePaths, listSourcePaths, buildLocal } from './chunk-CPBESPWK.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-KOD4GBQ5.mjs';
+import { existsSync, promises } from 'fs';
+import path from 'path';
+import { writablePath, readablePath, anthropicAuthoringModel, runAuthoringTurn } from '@cimplify/sdk/interactives/authoring';
+
+var API_KEY_ENV = "ANTHROPIC_API_KEY";
+var MODEL_ENV = "CIMPLIFY_AI_MODEL";
+var MAX_HISTORY_MESSAGES = 80;
+function inside(root, rel) {
+  const abs = path.resolve(root, ...rel.split("/"));
+  const base = path.resolve(root);
+  if (abs !== base && !abs.startsWith(base + path.sep)) throw new Error(`${rel} is outside the project`);
+  return abs;
+}
+function fileProject(root) {
+  return {
+    async list() {
+      const tracked = await collectSourcePaths(root);
+      const paths = tracked ?? (await listSourcePaths(root)).paths;
+      return [...paths].sort();
+    },
+    async read(rel) {
+      if (readablePath(rel) === null) return null;
+      try {
+        return await promises.readFile(inside(root, rel), "utf8");
+      } catch (err) {
+        if (err.code === "ENOENT" || err.code === "EISDIR") return null;
+        throw err;
+      }
+    },
+    async write(rel, content) {
+      if (writablePath(rel) === null) throw new Error(`${rel} is not writable`);
+      const target = inside(root, rel);
+      await promises.mkdir(path.dirname(target), { recursive: true });
+      await promises.writeFile(target, content);
+    },
+    async remove(rel) {
+      if (writablePath(rel) === null) throw new Error(`${rel} is not writable`);
+      const target = inside(root, rel);
+      if (!existsSync(target)) return false;
+      await promises.rm(target);
+      return true;
+    }
+  };
+}
+function authoringDiagnostics(diagnostics) {
+  return diagnostics.map((d) => ({ severity: d.severity, code: d.code, message: d.message, file: d.file, line: d.line }));
+}
+function buildCheck(build) {
+  return async () => authoringDiagnostics((await build()).result.diagnostics);
+}
+function modelFromEnv(env = process.env) {
+  const apiKey = env[API_KEY_ENV];
+  if (apiKey === void 0 || apiKey.trim().length === 0) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `asking the AI to change an Interactive needs ${API_KEY_ENV}`, {
+      remediation: `Export ${API_KEY_ENV}=<your Anthropic API key> in the shell that runs cimplify, then try again. Set ${MODEL_ENV} to use a different model.`
+    });
+  }
+  const model = env[MODEL_ENV]?.trim();
+  return anthropicAuthoringModel({ apiKey: apiKey.trim(), ...model ? { model } : {} });
+}
+function trimHistory(messages, limit = MAX_HISTORY_MESSAGES) {
+  if (messages.length <= limit) return [...messages];
+  for (let start = messages.length - limit; start < messages.length; start++) {
+    if (messages[start].role === "user") return messages.slice(start);
+  }
+  return [];
+}
+async function askAuthoring(root, request, options) {
+  const text = request.trim();
+  if (text.length === 0) throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, 'say what to change, for example: cimplify ai "add traffic to the loop"');
+  return runAuthoringTurn({
+    model: options.model,
+    project: fileProject(root),
+    check: options.check ?? buildCheck(() => buildLocal(root)),
+    request: text,
+    history: options.history,
+    onEvent: options.onEvent
+  });
+}
+
+export { askAuthoring, buildCheck, fileProject, modelFromEnv, trimHistory };

package/dist/{chunk-LZEG3FEY.mjs → chunk-Q6CF4C3E.mjs}

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
-import { promptYesNo } from './chunk-TH4XENKH.mjs';
-import { gitRemoteHead, managedProviderForHost } from './chunk-UTD34C2H.mjs';
-import { TOKEN_PURPOSE, REPO_PROVIDER, isManagedRepoProvider, REPO_PROVIDER_VALUES } from './chunk-2MKZKUVH.mjs';
-import { parseArgs, flagString, flagBool } from './chunk-5KYR6WJB.mjs';
-import { ApiClient } from './chunk-NYXA6X56.mjs';
-import { readAuth, readProjectLink } from './chunk-MLE4MVYC.mjs';
-import { CliError, CLI_ERROR_CODE, isJsonMode, result, dim, success, info, bold } from './chunk-3QUK5BPY.mjs';
+import { promptYesNo } from './chunk-I4HNHPEM.mjs';
+import { gitRemoteHead, managedProviderForHost } from './chunk-EDZSOL5O.mjs';
+import { TOKEN_PURPOSE, REPO_PROVIDER, isManagedRepoProvider, REPO_PROVIDER_VALUES } from './chunk-LLRUOIMU.mjs';
+import { parseArgs, flagString, flagBool } from './chunk-XQAHREKO.mjs';
+import { ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuth, readProjectLink } from './chunk-TT4YI33G.mjs';
+import { CliError, CLI_ERROR_CODE, isJsonMode, result, dim, success, info, bold } from './chunk-KOD4GBQ5.mjs';
 
 // src/commands/repo.ts
 var SUB_PROVISION = "provision";

package/dist/chunk-RP66A52P.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { sha256 } from './chunk-25ZPFHLF.mjs';
+import { resolveBaseUrl, ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuthOrNull } from './chunk-TT4YI33G.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-KOD4GBQ5.mjs';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+var CONTENT_REMOTE_ENV = "CIMPLIFY_CONTENT_REMOTE";
+var CONTENT_FAKE_ROOT_ENV = "CIMPLIFY_CONTENT_FAKE_ROOT";
+var FAKE_REMOTE = "fake";
+var RESOLVE_PATH = "/v1/content/resolve";
+var BLOB_PATH = "/v1/content/blobs/";
+var RESOLUTION_FILE = "resolution.json";
+var BLOB_DIR = "blobs";
+var HttpContentRemote = class {
+  client;
+  baseUrl;
+  constructor(client, baseUrl) {
+    this.client = client;
+    this.baseUrl = baseUrl;
+  }
+  async resolve(items) {
+    const resolution = await this.client.post(RESOLVE_PATH, { items });
+    return resolution.versions;
+  }
+  async blob(digest) {
+    const url = new URL(`${BLOB_PATH}${digest}`, this.baseUrl).toString();
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `Workshop has no blob ${digest} (HTTP ${response.status})`);
+    }
+    const bytes = Buffer.from(await response.arrayBuffer());
+    if (sha256(bytes) !== digest) {
+      throw new CliError(CLI_ERROR_CODE.NETWORK_ERROR, `the Workshop blob ${digest} did not match its digest`);
+    }
+    return bytes;
+  }
+};
+var DirectoryContentRemote = class {
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  async resolve(items) {
+    const file = path.join(this.root, RESOLUTION_FILE);
+    if (!existsSync(file)) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `the local Workshop at ${this.root} has no ${RESOLUTION_FILE}`);
+    const all = JSON.parse(readFileSync(file, "utf8"));
+    const wanted = new Set(items.map((i) => i.item));
+    const chosen = /* @__PURE__ */ new Map();
+    const queue = all.filter((v) => wanted.has(v.item));
+    for (const item of wanted) {
+      if (!queue.some((v) => v.item === item)) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `the local Workshop has no ${item}`);
+    }
+    while (queue.length > 0) {
+      const next = queue.shift();
+      if (chosen.has(next.item)) continue;
+      chosen.set(next.item, { ...next, requested: wanted.has(next.item) });
+      const manifest = JSON.parse((await this.blob(next.version_digest)).toString("utf8"));
+      for (const dependency of manifest.dependencies ?? []) {
+        const found = all.find((v) => v.version_digest === dependency.version_digest);
+        if (found !== void 0) queue.push(found);
+      }
+    }
+    return [...chosen.values()];
+  }
+  async blob(digest) {
+    const file = path.join(this.root, BLOB_DIR, digest);
+    if (!existsSync(file)) throw new CliError(CLI_ERROR_CODE.NOT_FOUND, `the local Workshop has no blob ${digest}`);
+    return readFileSync(file);
+  }
+};
+async function contentRemoteFromEnv() {
+  if (process.env[CONTENT_REMOTE_ENV] === FAKE_REMOTE) {
+    const root = process.env[CONTENT_FAKE_ROOT_ENV];
+    if (root === void 0 || root.length === 0) {
+      throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${CONTENT_REMOTE_ENV}=${FAKE_REMOTE} needs ${CONTENT_FAKE_ROOT_ENV} to name a local Workshop directory`);
+    }
+    return new DirectoryContentRemote(root);
+  }
+  const auth = await readAuthOrNull();
+  const baseUrl = auth?.apiBaseUrl ?? resolveBaseUrl();
+  return new HttpContentRemote(auth === null ? ApiClient.unauthenticated(baseUrl) : ApiClient.fromAuth(auth), baseUrl);
+}
+
+export { contentRemoteFromEnv };

package/dist/{chunk-I2UP7YTG.mjs → chunk-SAXGWS2K.mjs}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { CliError, CLI_ERROR_CODE } from './chunk-3QUK5BPY.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-KOD4GBQ5.mjs';
 
 // src/envfile.ts
 var COMMENT_CHAR = "#";

package/dist/chunk-SCKQ4XSD.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { parseManifest, MANIFEST_FILE } from './chunk-T4MW3PD4.mjs';
+import { formatDiagnostic } from './chunk-SGT5IJVW.mjs';
+import { CliError, CLI_ERROR_CODE } from './chunk-KOD4GBQ5.mjs';
+import { promises } from 'fs';
+import path from 'path';
+
+// src/interactives/remote/port.ts
+var CHANNELS = ["live", "test"];
+var RemoteError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RemoteError";
+    this.code = code;
+  }
+};
+async function readInteractiveId(root) {
+  const parsed = parseManifest(await promises.readFile(path.join(root, MANIFEST_FILE), "utf8"));
+  if (parsed.manifest === null) {
+    throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, `${MANIFEST_FILE} is invalid:
+${parsed.diagnostics.map(formatDiagnostic).join("\n")}`);
+  }
+  if (parsed.manifest.identity.id === null) {
+    throw new CliError(CLI_ERROR_CODE.NOT_LINKED, "this Interactive has not been published yet", {
+      remediation: "Run `cimplify publish --channel test` to publish it."
+    });
+  }
+  return parsed.manifest.identity.id;
+}
+async function remoteCall(call) {
+  try {
+    return await call();
+  } catch (err) {
+    if (!(err instanceof RemoteError)) throw err;
+    const code = err.code === "not_found" ? CLI_ERROR_CODE.NOT_FOUND : err.code === "unauthorized" ? CLI_ERROR_CODE.UNAUTHORIZED : CLI_ERROR_CODE.INVALID_INPUT;
+    throw new CliError(code, err.message);
+  }
+}
+
+export { CHANNELS, RemoteError, readInteractiveId, remoteCall };