@runcofactor/cli 0.10.0

package/dist/property-UXLOLPTD.js

@@ -0,0 +1,701 @@
+import { createRequire as __cr } from "module"; const require = __cr(import.meta.url);
+import {
+  apiRequest,
+  fetchProperties,
+  getApplicationArg
+} from "./chunk-WOHL4FTB.js";
+import "./chunk-SJJW77WN.js";
+import "./chunk-3CZU7XCS.js";
+import {
+  getArgValue,
+  hasFlag,
+  resolveConfig
+} from "./chunk-A4OFTUVV.js";
+import "./chunk-JWHYXEA2.js";
+import "./chunk-VKVL7WBN.js";
+
+// src/property.ts
+import process2 from "process";
+
+// src/property-skill.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import process from "process";
+var HERE = dirname(fileURLToPath(import.meta.url));
+var GUIDE_PATH = join(HERE, "property-skill-guide.md");
+var SECTIONS = [
+  "general",
+  "technology",
+  "product",
+  "ui",
+  "tenancy",
+  "auth",
+  "roles_permissions",
+  "navigation",
+  "feature_gating",
+  "environments",
+  "data_lifecycle",
+  "async_realtime",
+  "localization",
+  "feedback_errors",
+  "idiosyncrasies"
+];
+function printSkillHelp() {
+  console.log(
+    [
+      "canary application skill: Manage an application's app skill (per-application knowledge for QA browser agents). Alias: canary property skill. (--property accepted as an alias for --application.)",
+      "",
+      "Sub-commands:",
+      "  guide                                                          Print the full authoring methodology (start here)",
+      "  list      [--application <id>] [--section S] [--format json|table]",
+      "  get       --application <id> --section S --key K [--version N] [--format json|md]",
+      '  set       --application <id> --section S --key K --label L --content @file|"text" [--source-id <repo@sha>]',
+      "  delete    --application <id> --section S --key K",
+      "  history   --application <id> --section S --key K [--format json|table]",
+      "  export    --application <id> [--format md|json]",
+      "  import    --application <id> --file <bundle.json> [--source-id <repo@sha>]",
+      "",
+      "New to app skills? Run `canary application skill guide` for the authoring methodology.",
+      "",
+      "Sections:",
+      "  " + SECTIONS.join(", "),
+      "",
+      "Notes:",
+      "  --content @path   reads content from a file (preferred for multi-line markdown)",
+      '  --content "text"  literal content string',
+      '  Source defaults to "cli". Provide --source-id <repo@sha> for provenance.',
+      "",
+      "Bundle.json shape for import:",
+      '  { "items": [ { "section": S, "itemKey": K, "itemLabel": L, "content": "..." }, ... ] }'
+    ].join("\n")
+  );
+}
+function readContent(value) {
+  if (value.startsWith("@")) {
+    const path = value.slice(1);
+    return readFileSync(path, "utf8");
+  }
+  return value;
+}
+function isSection(s) {
+  return !!s && SECTIONS.includes(s);
+}
+async function handleList(argv, apiUrl, token) {
+  const propertyId = getApplicationArg(argv);
+  const section = getArgValue(argv, "--section");
+  const format = getArgValue(argv, "--format") ?? (hasFlag(argv, "--json") ? "json" : "table");
+  if (!propertyId) {
+    console.error("Error: --application is required (alias: --property).");
+    process.exit(1);
+  }
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    `/org/properties/${propertyId}/context`
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process.exit(1);
+  }
+  let items = result.data?.items ?? [];
+  if (section) items = items.filter((i) => i.section === section);
+  if (format === "json") {
+    console.log(JSON.stringify(items, null, 2));
+    return;
+  }
+  if (items.length === 0) {
+    console.log("(no items)");
+    return;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const arr = grouped.get(item.section) ?? [];
+    arr.push(item);
+    grouped.set(item.section, arr);
+  }
+  for (const sec of SECTIONS) {
+    const arr = grouped.get(sec);
+    if (!arr || arr.length === 0) continue;
+    console.log(`
+[${sec}]`);
+    for (const item of arr) {
+      const provenance = item.source === "cli" && item.sourceId ? ` (${item.sourceId})` : item.source !== "cli" ? ` (${item.source})` : "";
+      console.log(`  ${item.itemKey} \u2014 ${item.itemLabel}${provenance}`);
+    }
+  }
+}
+async function handleGet(argv, apiUrl, token) {
+  const propertyId = getApplicationArg(argv);
+  const section = getArgValue(argv, "--section");
+  const itemKey = getArgValue(argv, "--key");
+  const versionArg = getArgValue(argv, "--version");
+  const format = getArgValue(argv, "--format") ?? "md";
+  if (!propertyId || !section || !itemKey) {
+    console.error("Error: --application, --section, --key are required.");
+    process.exit(1);
+  }
+  if (!isSection(section)) {
+    console.error(`Error: invalid section "${section}". One of: ${SECTIONS.join(", ")}`);
+    process.exit(1);
+  }
+  if (versionArg) {
+    const v = Number(versionArg);
+    const result2 = await apiRequest(
+      apiUrl,
+      token,
+      "GET",
+      `/org/properties/${propertyId}/context/history?section=${section}&itemKey=${encodeURIComponent(itemKey)}`
+    );
+    if (!result2.ok) {
+      console.error(`Error: ${result2.error ?? "Unknown error"}`);
+      process.exit(1);
+    }
+    const item2 = (result2.data ?? []).find((i) => i.version === v);
+    if (!item2) {
+      console.error(`Error: no version ${v} for ${section}/${itemKey}`);
+      process.exit(1);
+    }
+    printItem(item2, format);
+    return;
+  }
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    `/org/properties/${propertyId}/context`
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process.exit(1);
+  }
+  const item = (result.data?.items ?? []).find(
+    (i) => i.section === section && i.itemKey === itemKey
+  );
+  if (!item) {
+    console.error(`Error: no item ${section}/${itemKey}`);
+    process.exit(1);
+  }
+  printItem(item, format);
+}
+function printItem(item, format) {
+  if (format === "json") {
+    console.log(JSON.stringify(item, null, 2));
+    return;
+  }
+  console.log(`# ${item.itemLabel}`);
+  console.log(`section: ${item.section}`);
+  console.log(`key: ${item.itemKey}`);
+  console.log(`version: ${item.version}`);
+  console.log(`source: ${item.source}${item.sourceId ? ` (${item.sourceId})` : ""}`);
+  console.log("");
+  console.log(item.content);
+}
+async function handleSet(argv, apiUrl, token) {
+  const propertyId = getApplicationArg(argv);
+  const section = getArgValue(argv, "--section");
+  const itemKey = getArgValue(argv, "--key");
+  const itemLabel = getArgValue(argv, "--label");
+  const contentArg = getArgValue(argv, "--content");
+  const sourceId = getArgValue(argv, "--source-id");
+  if (!propertyId || !section || !itemKey || !itemLabel || contentArg === void 0) {
+    console.error("Error: --application, --section, --key, --label, --content are required.");
+    process.exit(1);
+  }
+  if (!isSection(section)) {
+    console.error(`Error: invalid section "${section}". One of: ${SECTIONS.join(", ")}`);
+    process.exit(1);
+  }
+  const content = readContent(contentArg);
+  const body = {
+    section,
+    itemKey,
+    itemLabel,
+    content,
+    source: "cli"
+  };
+  if (sourceId !== void 0) body.sourceId = sourceId;
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "PUT",
+    `/org/properties/${propertyId}/context/items`,
+    body
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process.exit(1);
+  }
+  console.log(`Set [${section}] ${itemKey} (v${result.data?.version ?? "?"})`);
+}
+async function handleDelete(argv, apiUrl, token) {
+  const propertyId = getApplicationArg(argv);
+  const section = getArgValue(argv, "--section");
+  const itemKey = getArgValue(argv, "--key");
+  if (!propertyId || !section || !itemKey) {
+    console.error("Error: --application, --section, --key are required.");
+    process.exit(1);
+  }
+  if (!isSection(section)) {
+    console.error(`Error: invalid section "${section}". One of: ${SECTIONS.join(", ")}`);
+    process.exit(1);
+  }
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "DELETE",
+    `/org/properties/${propertyId}/context/items`,
+    { section, itemKey }
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process.exit(1);
+  }
+  console.log(`Deleted [${section}] ${itemKey}`);
+}
+async function handleHistory(argv, apiUrl, token) {
+  const propertyId = getApplicationArg(argv);
+  const section = getArgValue(argv, "--section");
+  const itemKey = getArgValue(argv, "--key");
+  const format = getArgValue(argv, "--format") ?? "table";
+  if (!propertyId || !section || !itemKey) {
+    console.error("Error: --application, --section, --key are required.");
+    process.exit(1);
+  }
+  if (!isSection(section)) {
+    console.error(`Error: invalid section "${section}". One of: ${SECTIONS.join(", ")}`);
+    process.exit(1);
+  }
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    `/org/properties/${propertyId}/context/history?section=${section}&itemKey=${encodeURIComponent(itemKey)}`
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process.exit(1);
+  }
+  const versions = result.data ?? [];
+  if (format === "json") {
+    console.log(JSON.stringify(versions, null, 2));
+    return;
+  }
+  if (versions.length === 0) {
+    console.log("(no history)");
+    return;
+  }
+  for (const v of versions) {
+    const provenance = v.sourceId ? ` (${v.sourceId})` : "";
+    console.log(`v${v.version}  ${v.source}${provenance}  ${v.createdAt}`);
+  }
+}
+async function handleExport(argv, apiUrl, token) {
+  const propertyId = getApplicationArg(argv);
+  const format = getArgValue(argv, "--format") ?? "md";
+  if (!propertyId) {
+    console.error("Error: --application is required (alias: --property).");
+    process.exit(1);
+  }
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "GET",
+    `/org/properties/${propertyId}/context`
+  );
+  if (!result.ok) {
+    console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process.exit(1);
+  }
+  const items = result.data?.items ?? [];
+  if (format === "json") {
+    console.log(JSON.stringify({ items }, null, 2));
+    return;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const arr = grouped.get(item.section) ?? [];
+    arr.push(item);
+    grouped.set(item.section, arr);
+  }
+  for (const sec of SECTIONS) {
+    const arr = grouped.get(sec);
+    if (!arr || arr.length === 0) continue;
+    console.log(`## ${sec}`);
+    console.log("");
+    for (const item of arr) {
+      console.log(`### ${item.itemLabel} (\`${item.itemKey}\`)`);
+      console.log("");
+      console.log(item.content);
+      console.log("");
+    }
+  }
+}
+async function handleImport(argv, apiUrl, token) {
+  const propertyId = getApplicationArg(argv);
+  const file = getArgValue(argv, "--file");
+  const sourceId = getArgValue(argv, "--source-id");
+  if (!propertyId || !file) {
+    console.error("Error: --application and --file are required.");
+    process.exit(1);
+  }
+  let bundle;
+  try {
+    bundle = JSON.parse(readFileSync(file, "utf8"));
+  } catch (err) {
+    console.error(`Error parsing ${file}: ${err.message}`);
+    process.exit(1);
+    return;
+  }
+  if (!bundle.items || !Array.isArray(bundle.items)) {
+    console.error('Error: bundle.json must have an "items" array.');
+    process.exit(1);
+  }
+  let ok = 0;
+  let fail = 0;
+  for (const item of bundle.items) {
+    if (!isSection(item.section)) {
+      console.error(`  \u2717 [${item.section}] ${item.itemKey}: invalid section`);
+      fail++;
+      continue;
+    }
+    const body = {
+      section: item.section,
+      itemKey: item.itemKey,
+      itemLabel: item.itemLabel,
+      content: item.content,
+      source: "cli"
+    };
+    if (sourceId) body.sourceId = sourceId;
+    const result = await apiRequest(
+      apiUrl,
+      token,
+      "PUT",
+      `/org/properties/${propertyId}/context/items`,
+      body
+    );
+    if (result.ok) {
+      console.log(`  \u2713 [${item.section}] ${item.itemKey} (v${result.data?.version ?? "?"})`);
+      ok++;
+    } else {
+      console.error(`  \u2717 [${item.section}] ${item.itemKey}: ${result.error ?? "Unknown error"}`);
+      fail++;
+    }
+  }
+  console.log(`
+Imported ${ok}/${ok + fail} items${fail ? ` (${fail} failed)` : ""}.`);
+  if (fail > 0) process.exit(1);
+}
+function handleGuide() {
+  try {
+    const guide = readFileSync(GUIDE_PATH, "utf8");
+    process.stdout.write(guide);
+    if (!guide.endsWith("\n")) process.stdout.write("\n");
+  } catch (err) {
+    console.error(`Error: could not read authoring guide at ${GUIDE_PATH}`);
+    console.error(err.message);
+    process.exit(1);
+  }
+}
+async function runPropertySkill(argv, apiUrl, token) {
+  const [action, ...rest] = argv;
+  if (!action || action === "help" || hasFlag(argv, "--help", "-h")) {
+    printSkillHelp();
+    return;
+  }
+  switch (action) {
+    case "guide":
+      handleGuide();
+      return;
+    case "list":
+      await handleList(rest, apiUrl, token);
+      break;
+    case "get":
+      await handleGet(rest, apiUrl, token);
+      break;
+    case "set":
+      await handleSet(rest, apiUrl, token);
+      break;
+    case "delete":
+      await handleDelete(rest, apiUrl, token);
+      break;
+    case "history":
+      await handleHistory(rest, apiUrl, token);
+      break;
+    case "export":
+      await handleExport(rest, apiUrl, token);
+      break;
+    case "import":
+      await handleImport(rest, apiUrl, token);
+      break;
+    default:
+      console.error(`Unknown skill action: ${action}`);
+      printSkillHelp();
+      process.exit(1);
+  }
+}
+
+// src/property.ts
+function pad(s, n) {
+  return s.padEnd(n);
+}
+function printHelp() {
+  console.log(
+    [
+      "canary application: Manage applications (alias: canary property)",
+      "",
+      "Sub-commands:",
+      "  list                              List all applications",
+      "  create [options]                  Create a new application",
+      "  repo link [options]               Link a GitHub repo to an application",
+      "  repo update [options]             Update an existing repo link",
+      "  repo unlink [options]             Unlink a GitHub repo from an application",
+      "  skill <action> [options]          Manage the application's app skill (run `canary application skill help` for details)",
+      "",
+      "Create options:",
+      "  --name <name>                     Application name (required)",
+      "  --base-url <url>                  Application base URL (required)",
+      "  --description <text>              Optional description",
+      "  --agent-context <text>            Optional agent context (max 8000 chars)",
+      "  --env-var <NAME[:sensitive]>      Declare a per-environment variable (repeatable); values set per-environment, injected as $var.ENV.<NAME>",
+      "",
+      "Repo link/update/unlink options:",
+      "  --application <app_xxx|uuid>      Application ID (required; alias: --property)",
+      "  --repo <owner/name>               Repo full name (required for link/unlink)",
+      "  --repo-id <uuid>                  Repo link UUID (required for update)",
+      "  --role <frontend|backend|...>     Conventional role (free-form)",
+      "  --root-dir <path>                 Monorepo subdirectory hint",
+      "  --agent-hint <text>               Free-form hint for the planner agent",
+      "",
+      "Common options:",
+      "  --json                            Output as JSON"
+    ].join("\n")
+  );
+}
+async function handleList2(argv, apiUrl, token) {
+  const json = hasFlag(argv, "--json");
+  const properties = await fetchProperties(apiUrl, token);
+  if (json) {
+    console.log(JSON.stringify(properties, null, 2));
+    return;
+  }
+  if (properties.length === 0) {
+    console.log("No applications found.");
+    return;
+  }
+  console.log(`${pad("Name", 30)} ${pad("Base URL", 40)} ID`);
+  for (const p of properties) {
+    console.log(`${pad(p.name, 30)} ${pad(p.baseUrl, 40)} ${p.id}`);
+  }
+  console.log("");
+  for (const p of properties) {
+    const reposRes = await apiRequest(
+      apiUrl,
+      token,
+      "GET",
+      `/org/properties/${p.id}/github-repos`
+    );
+    const repos = reposRes.ok ? reposRes.items ?? [] : [];
+    if (repos.length > 0) {
+      console.log(`${p.name} repos:`);
+      for (const r of repos) {
+        const dir = r.rootDir && r.rootDir !== "/" ? ` (${r.rootDir})` : "";
+        const role = r.role ? ` [${r.role}]` : "";
+        console.log(`  ${r.repoFullName}:${r.defaultBranch}${role}${dir}`);
+      }
+    }
+  }
+}
+function parseEnvVarDefinitions(argv) {
+  const defs = [];
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] !== "--env-var") continue;
+    const raw = argv[i + 1];
+    if (!raw || raw.startsWith("-")) continue;
+    const [name, modifier] = raw.split(":");
+    if (!name) continue;
+    defs.push({ name, ...modifier === "sensitive" ? { sensitive: true } : {} });
+  }
+  return defs;
+}
+async function handleCreate(argv, apiUrl, token) {
+  const json = hasFlag(argv, "--json");
+  const name = getArgValue(argv, "--name");
+  const baseUrl = getArgValue(argv, "--base-url");
+  const description = getArgValue(argv, "--description");
+  const agentContext = getArgValue(argv, "--agent-context");
+  const envVarDefinitions = parseEnvVarDefinitions(argv);
+  if (!name || !baseUrl) {
+    console.error("Error: --name and --base-url are required.");
+    console.error("Usage: canary application create --name <name> --base-url <url>");
+    process2.exit(1);
+  }
+  const body = { name, baseUrl };
+  if (description !== void 0) body.description = description;
+  if (agentContext !== void 0) body.agentContext = agentContext;
+  if (envVarDefinitions.length > 0) body.envVarDefinitions = envVarDefinitions;
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "POST",
+    "/org/properties",
+    body
+  );
+  if (!result.ok) {
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.error(`Error: ${result.error ?? "Unknown error"}`);
+    }
+    process2.exit(1);
+  }
+  if (json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`Created application "${name}" (${result.id})`);
+}
+async function handleRepoLink(argv, apiUrl, token) {
+  const json = hasFlag(argv, "--json");
+  const propertyId = getApplicationArg(argv);
+  const repo = getArgValue(argv, "--repo");
+  const role = getArgValue(argv, "--role");
+  const rootDir = getArgValue(argv, "--root-dir");
+  const agentHint = getArgValue(argv, "--agent-hint");
+  if (!propertyId || !repo) {
+    console.error("Error: --application and --repo are required.");
+    process2.exit(1);
+  }
+  const body = { repoFullName: repo };
+  if (role !== void 0) body.role = role;
+  if (rootDir !== void 0) body.rootDir = rootDir;
+  if (agentHint !== void 0) body.agentHint = agentHint;
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "POST",
+    `/org/properties/${propertyId}/github-repos`,
+    body
+  );
+  if (!result.ok) {
+    if (json) console.log(JSON.stringify(result, null, 2));
+    else console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process2.exit(1);
+  }
+  if (json) console.log(JSON.stringify(result, null, 2));
+  else console.log(`Linked ${repo} to application ${propertyId} (${result.id})`);
+}
+async function handleRepoUpdate(argv, apiUrl, token) {
+  const json = hasFlag(argv, "--json");
+  const propertyId = getApplicationArg(argv);
+  const repoId = getArgValue(argv, "--repo-id");
+  const role = getArgValue(argv, "--role");
+  const rootDir = getArgValue(argv, "--root-dir");
+  const agentHint = getArgValue(argv, "--agent-hint");
+  if (!propertyId || !repoId) {
+    console.error("Error: --application and --repo-id are required.");
+    process2.exit(1);
+  }
+  const body = {};
+  if (role !== void 0) body.role = role;
+  if (rootDir !== void 0) body.rootDir = rootDir;
+  if (agentHint !== void 0) body.agentHint = agentHint;
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "PATCH",
+    `/org/properties/${propertyId}/github-repos/${repoId}`,
+    body
+  );
+  if (!result.ok) {
+    if (json) console.log(JSON.stringify(result, null, 2));
+    else console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process2.exit(1);
+  }
+  if (json) console.log(JSON.stringify(result, null, 2));
+  else console.log(`Updated repo link ${repoId}`);
+}
+async function handleRepoUnlink(argv, apiUrl, token) {
+  const json = hasFlag(argv, "--json");
+  const propertyId = getApplicationArg(argv);
+  const repo = getArgValue(argv, "--repo");
+  if (!propertyId || !repo) {
+    console.error("Error: --application and --repo are required.");
+    process2.exit(1);
+  }
+  const result = await apiRequest(
+    apiUrl,
+    token,
+    "DELETE",
+    `/org/properties/${propertyId}/github-repos/${encodeURIComponent(repo)}`
+  );
+  if (!result.ok) {
+    if (json) console.log(JSON.stringify(result, null, 2));
+    else console.error(`Error: ${result.error ?? "Unknown error"}`);
+    process2.exit(1);
+  }
+  if (json) console.log(JSON.stringify(result, null, 2));
+  else console.log(`Unlinked ${repo} from application ${propertyId}`);
+}
+async function handleRepo(argv, apiUrl, token) {
+  const [action, ...rest] = argv;
+  switch (action) {
+    case "link":
+      await handleRepoLink(rest, apiUrl, token);
+      break;
+    case "update":
+      await handleRepoUpdate(rest, apiUrl, token);
+      break;
+    case "unlink":
+      await handleRepoUnlink(rest, apiUrl, token);
+      break;
+    default:
+      console.error(`Unknown repo action: ${action ?? "(none)"}`);
+      printHelp();
+      process2.exit(1);
+  }
+}
+async function runProperty(argv) {
+  const [subCommand, ...rest] = argv;
+  if (!subCommand || subCommand === "help" || hasFlag(argv, "--help", "-h")) {
+    printHelp();
+    return;
+  }
+  if (subCommand === "skill") {
+    const skillAction = rest[0];
+    if (!skillAction || skillAction === "help" || skillAction === "guide") {
+      await runPropertySkill(rest, "", "");
+      return;
+    }
+  }
+  const { apiUrl, token } = await resolveConfig(argv);
+  const globalFlags = /* @__PURE__ */ new Set(["--env", "--api-url", "--token"]);
+  const args = rest.filter((arg, i) => {
+    if (globalFlags.has(arg)) return false;
+    if (i > 0 && globalFlags.has(rest[i - 1])) return false;
+    return true;
+  });
+  switch (subCommand) {
+    case "list":
+      await handleList2(args, apiUrl, token);
+      break;
+    case "create":
+      await handleCreate(args, apiUrl, token);
+      break;
+    case "repo":
+      await handleRepo(args, apiUrl, token);
+      break;
+    case "skill":
+      await runPropertySkill(args, apiUrl, token);
+      break;
+    default:
+      console.error(`Unknown sub-command: ${subCommand}`);
+      printHelp();
+      process2.exit(1);
+  }
+}
+export {
+  runProperty
+};
+//# sourceMappingURL=property-UXLOLPTD.js.map