@iowarp/clio-coder 0.3.0

package/dist/share-D36RQCXM.js

@@ -0,0 +1,241 @@
+import {
+  importShareArchive,
+  planShareImport,
+  writeShareArchive
+} from "./chunk-AMFR5YA3.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/share.ts
+import { resolve } from "node:path";
+var HELP = `clio-coder share <command>
+
+Export and import portable Clio project/resource archives.
+
+Commands:
+  clio-coder share export --out <path> [--project|--user|--both] [--context] [--prompts] [--skills] [--settings] [--extensions]
+  clio-coder share import <path> [--dry-run] [--force] [--project|--user] [--json]
+  clio-coder share inspect <path> [--json]
+
+Aliases:
+  clio-coder export --out <path> ...
+  clio-coder import <path> ...
+`;
+function parse(argv) {
+  const out = { positional: [], json: false, dryRun: false, force: false, help: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (!arg) continue;
+    if (!out.command && !arg.startsWith("-")) {
+      out.command = arg;
+      continue;
+    }
+    const need = () => {
+      const value = argv[i + 1];
+      if (!value) return null;
+      i += 1;
+      return value;
+    };
+    switch (arg) {
+      case "--out": {
+        const value = need();
+        if (!value) return null;
+        out.out = value;
+        break;
+      }
+      case "--project":
+        if (out.scope && out.scope !== "project") return null;
+        out.scope = "project";
+        break;
+      case "--user":
+        if (out.scope && out.scope !== "user") return null;
+        out.scope = "user";
+        break;
+      case "--both":
+        if (out.scope && out.scope !== "both") return null;
+        out.scope = "both";
+        break;
+      case "--json":
+        out.json = true;
+        break;
+      case "--dry-run":
+        out.dryRun = true;
+        break;
+      case "--force":
+      case "-f":
+        out.force = true;
+        break;
+      case "--context":
+        out.includeContext = true;
+        break;
+      case "--prompts":
+        out.includePrompts = true;
+        break;
+      case "--skills":
+        out.includeSkills = true;
+        break;
+      case "--settings":
+        out.includeSettings = true;
+        break;
+      case "--extensions":
+        out.includeExtensions = true;
+        break;
+      case "--all":
+        out.includeContext = true;
+        out.includePrompts = true;
+        out.includeSkills = true;
+        out.includeSettings = true;
+        out.includeExtensions = true;
+        break;
+      case "--help":
+      case "-h":
+        out.help = true;
+        break;
+      default:
+        if (arg.startsWith("-")) return null;
+        out.positional.push(arg);
+    }
+  }
+  return out;
+}
+function hasBlockingDiagnostics(diagnostics) {
+  return diagnostics.some((diag) => diag.type === "error" || diag.type === "conflict");
+}
+function printDiagnostics(diagnostics) {
+  for (const diag of diagnostics) {
+    const detail = diag.path ? `${diag.message}: ${diag.path}` : diag.message;
+    if (diag.type === "error" || diag.type === "conflict") printError(detail);
+    else process.stderr.write(`warning: ${detail}
+`);
+  }
+}
+function printRecovery(plan) {
+  if (!plan.recovery) return;
+  process.stderr.write("recovery: import stopped after a write failure\n");
+  process.stderr.write("written files:\n");
+  if (plan.recovery.written.length === 0) process.stderr.write("  none\n");
+  else {
+    for (const written of plan.recovery.written) process.stderr.write(`  ${written}
+`);
+  }
+  process.stderr.write("backups:\n");
+  if (plan.recovery.backups.length === 0) process.stderr.write("  none\n");
+  else {
+    for (const backup of plan.recovery.backups) process.stderr.write(`  ${backup}
+`);
+  }
+  if (plan.recovery.failed) process.stderr.write(`failed file:
+  ${plan.recovery.failed}
+`);
+}
+function exportOptions(parsed) {
+  return {
+    ...parsed.scope ? { scope: parsed.scope } : {},
+    ...parsed.includeContext !== void 0 ? { includeContext: parsed.includeContext } : {},
+    ...parsed.includePrompts !== void 0 ? { includePrompts: parsed.includePrompts } : {},
+    ...parsed.includeSkills !== void 0 ? { includeSkills: parsed.includeSkills } : {},
+    ...parsed.includeSettings !== void 0 ? { includeSettings: parsed.includeSettings } : {},
+    ...parsed.includeExtensions !== void 0 ? { includeExtensions: parsed.includeExtensions } : {}
+  };
+}
+function printPlan(plan, dryRun) {
+  printDiagnostics(plan.diagnostics);
+  printRecovery(plan);
+  const verb = dryRun ? "would" : "will";
+  const counts = /* @__PURE__ */ new Map();
+  for (const action of plan.actions) counts.set(action.action, (counts.get(action.action) ?? 0) + 1);
+  process.stdout.write(
+    `import ${dryRun ? "dry-run" : "plan"}: ${verb} write ${counts.get("write") ?? 0}, overwrite ${counts.get("overwrite") ?? 0}, skip ${counts.get("skip") ?? 0}, settings ${counts.get("settings") ?? 0}
+`
+  );
+  for (const action of plan.actions.slice(0, 12)) {
+    process.stdout.write(`  ${action.action.padEnd(9)} ${action.type.padEnd(15)} ${action.path}
+`);
+  }
+  if (plan.actions.length > 12) process.stdout.write(`  ... ${plan.actions.length - 12} more action(s)
+`);
+}
+function runShareCommand(argv) {
+  const parsed = parse(argv);
+  if (!parsed || parsed.help || !parsed.command) {
+    process.stdout.write(HELP);
+    return parsed ? 0 : 2;
+  }
+  switch (parsed.command) {
+    case "export": {
+      if (!parsed.out) {
+        process.stderr.write("usage: clio-coder share export --out <path>\n");
+        return 2;
+      }
+      const archive = writeShareArchive(resolve(parsed.out), exportOptions(parsed));
+      if (parsed.json) process.stdout.write(`${JSON.stringify({ archive }, null, 2)}
+`);
+      else printOk(`exported ${archive.files.length} item(s) to ${resolve(parsed.out)}`);
+      return 0;
+    }
+    case "import": {
+      const archivePath = parsed.positional[0];
+      if (!archivePath || parsed.positional.length !== 1) {
+        process.stderr.write("usage: clio-coder share import <path> [--dry-run] [--force]\n");
+        return 2;
+      }
+      const options = {
+        dryRun: parsed.dryRun,
+        force: parsed.force,
+        ...parsed.scope === "user" || parsed.scope === "project" ? { scope: parsed.scope } : {}
+      };
+      const plan = parsed.dryRun ? planShareImport(resolve(archivePath), options) : importShareArchive(resolve(archivePath), options);
+      if (parsed.json) process.stdout.write(`${JSON.stringify(plan, null, 2)}
+`);
+      else printPlan(plan, parsed.dryRun);
+      return hasBlockingDiagnostics(plan.diagnostics) ? 1 : 0;
+    }
+    case "inspect": {
+      const archivePath = parsed.positional[0];
+      if (!archivePath || parsed.positional.length !== 1) {
+        process.stderr.write("usage: clio-coder share inspect <path>\n");
+        return 2;
+      }
+      const plan = planShareImport(resolve(archivePath), { dryRun: true, force: true });
+      if (parsed.json)
+        process.stdout.write(`${JSON.stringify({ archive: plan.archive, diagnostics: plan.diagnostics }, null, 2)}
+`);
+      else {
+        printDiagnostics(plan.diagnostics);
+        const archive = plan.archive;
+        if (archive) {
+          process.stdout.write(
+            `archive: ${archive.manifest.format} clio=${archive.manifest.clioVersion} files=${archive.files.length} created=${archive.manifest.createdAt}
+`
+          );
+        }
+      }
+      return plan.diagnostics.some((diag) => diag.type === "error") ? 1 : 0;
+    }
+    default:
+      printError(`unknown share command: ${parsed.command}`);
+      process.stdout.write(HELP);
+      return 2;
+  }
+}
+function runExportCommand(argv) {
+  return runShareCommand(["export", ...argv]);
+}
+function runImportCommand(argv) {
+  return runShareCommand(["import", ...argv]);
+}
+export {
+  runExportCommand,
+  runImportCommand,
+  runShareCommand
+};
+//# sourceMappingURL=share-D36RQCXM.js.map

package/dist/skills-F2MRLELY.js

@@ -0,0 +1,445 @@
+import "./chunk-2J63S4SF.js";
+import {
+  discoverMarketplaceSkills,
+  installSkill,
+  loadSkills,
+  modelVisibleSkills,
+  updateSkills
+} from "./chunk-26BZQOAD.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  formatColumns,
+  printError,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+
+// src/cli/skills.ts
+import { resolve } from "node:path";
+var HELP = `clio-coder skills <command>
+
+Manage local Clio and Agent Skills-compatible skills.
+
+Commands:
+  clio-coder skills list [--json] [--all]
+  clio-coder skills search <query> [--json]
+  clio-coder skills inspect <name> [--json]
+  clio-coder skills validate [path] [--json]
+  clio-coder skills install <name|path|github-url>... [--user|--project] [--name <name>] [--force]
+  clio-coder skills install --category <category> [--user|--project] [--force]
+  clio-coder skills update <name> | --all [--force]
+  clio-coder skills sync [--force]
+  clio-coder skills eval <name|path> [--scenario <id>] [--target <id>] [--workspace <path>] [--timeout <seconds>] [--trust-fixtures] [--allow-network] [--json]
+
+search covers installed skills plus the local marketplace (a repo skills/
+catalog, CLIO_CODER_SKILL_CATALOG_DIR, or the skill-marketplace.json index).
+
+install resolves a bare name through that marketplace; a path or GitHub URL
+installs directly, and an existing local path always wins over a same-named
+marketplace entry. Several sources install in one command, and --category
+installs every marketplace skill in one catalog group (git, research, ...).
+
+eval (experimental) executes the skill's evals.md RED-GREEN scenarios: per
+scenario a baseline headless run without the skill, a treatment run with it,
+and a judge run scoring each Expected bullet from the transcripts. Exit is 1
+when a treatment bullet fails and 3 when a scenario was never measured (a
+truncated or unparseable judge response scores no bullet, which is not a skill
+failure). Every arm runs hermetic: the network tool plane is stripped from the
+child runs unless you pass --allow-network. The baseline and treatment arms run
+at autonomy full-auto in per-run disposable workspaces, because a headless run
+has no operator to approve anything and a gated arm measures the harness rather
+than the skill. --scenario takes a full id as written
+in evals.md, whose prefix is per-skill (S1, but also D2 in clio-dev, T3 in
+clio-test, F1 in find-skills, H2 in context-handoff), or a bare number that
+selects that scenario whatever its prefix. --json emits one JSONL row per
+(scenario, bullet) with schema: "experimental". --workspace copies an existing
+checkout into a throwaway seed; the source checkout is not mutated. Fixture
+commands declared in evals.md are real shell run in that seed; they only execute
+with --trust-fixtures, after you have reviewed the evals.md.
+`;
+function parse(argv) {
+  const out = {
+    positional: [],
+    json: false,
+    all: false,
+    help: false,
+    force: false,
+    trustFixtures: false,
+    allowNetwork: false
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === void 0) continue;
+    if (!out.command && !arg.startsWith("-")) {
+      out.command = arg;
+      continue;
+    }
+    switch (arg) {
+      case "--json":
+        out.json = true;
+        break;
+      case "--all":
+        out.all = true;
+        break;
+      case "--force":
+        out.force = true;
+        break;
+      case "--trust-fixtures":
+        out.trustFixtures = true;
+        break;
+      case "--allow-network":
+        out.allowNetwork = true;
+        break;
+      case "--name": {
+        const value = argv[i + 1];
+        if (!value || value.startsWith("-")) throw new Error("--name requires a value");
+        out.name = value;
+        i++;
+        break;
+      }
+      case "--category": {
+        const value = argv[i + 1];
+        if (!value || value.startsWith("-")) throw new Error("--category requires a value");
+        out.category = value;
+        i++;
+        break;
+      }
+      case "--scenario": {
+        const value = argv[i + 1];
+        if (!value || value.startsWith("-")) throw new Error("--scenario requires a value");
+        out.scenario = value;
+        i++;
+        break;
+      }
+      case "--target": {
+        const value = argv[i + 1];
+        if (!value || value.startsWith("-")) throw new Error("--target requires a value");
+        out.target = value;
+        i++;
+        break;
+      }
+      case "--workspace": {
+        const value = argv[i + 1];
+        if (!value || value.startsWith("-")) throw new Error("--workspace requires a value");
+        out.workspace = value;
+        i++;
+        break;
+      }
+      case "--timeout": {
+        const value = argv[i + 1];
+        const seconds = value === void 0 ? Number.NaN : Number.parseInt(value, 10);
+        if (!Number.isInteger(seconds) || seconds <= 0) throw new Error("--timeout requires a positive integer");
+        out.timeoutSeconds = seconds;
+        i++;
+        break;
+      }
+      case "--user":
+        if (out.scope && out.scope !== "user") throw new Error("--user and --project are mutually exclusive");
+        out.scope = "user";
+        break;
+      case "--project":
+        if (out.scope && out.scope !== "project") throw new Error("--user and --project are mutually exclusive");
+        out.scope = "project";
+        break;
+      case "--help":
+      case "-h":
+        out.help = true;
+        break;
+      default:
+        if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+        out.positional.push(arg);
+    }
+  }
+  return out;
+}
+function printUpdateReports(reports) {
+  if (reports.length === 0) {
+    process.stdout.write("skills: nothing to update (no installed skills with source-url provenance)\n");
+    return 0;
+  }
+  for (const report of reports) {
+    const detail = report.detail ? ` (${report.detail})` : "";
+    process.stdout.write(`${report.name}: ${report.status}${detail}
+`);
+  }
+  return reports.some((report) => report.status === "error") ? 1 : 0;
+}
+function printDiagnostics(diagnostics) {
+  for (const diag of diagnostics) {
+    const detail = diag.path ? `${diag.message}: ${diag.path}` : diag.message;
+    if (diag.type === "error") printError(detail);
+    else process.stderr.write(`warning: ${detail}
+`);
+  }
+}
+function skillRows(skills) {
+  return skills.map((skill) => [
+    skill.name,
+    skill.scope,
+    skill.source,
+    skill.trusted ? "trusted" : "untrusted",
+    skill.disableModelInvocation ? "manual" : "model",
+    skill.hash.slice(0, 12),
+    skill.description
+  ]);
+}
+function printList(skills) {
+  if (skills.length === 0) {
+    process.stdout.write("skills: none\n");
+    return;
+  }
+  process.stdout.write(
+    formatColumns([["name", "scope", "source", "trust", "invoke", "hash", "description"], ...skillRows(skills)])
+  );
+}
+function printInspect(skill) {
+  process.stdout.write(`name: ${skill.name}
+`);
+  process.stdout.write(`description: ${skill.description}
+`);
+  process.stdout.write(`path: ${skill.filePath}
+`);
+  process.stdout.write(`baseDir: ${skill.baseDir}
+`);
+  process.stdout.write(`scope: ${skill.scope}
+`);
+  process.stdout.write(`source: ${skill.source}
+`);
+  process.stdout.write(`trusted: ${skill.trusted}
+`);
+  process.stdout.write(`disableModelInvocation: ${skill.disableModelInvocation}
+`);
+  process.stdout.write(`hash: ${skill.hash}
+`);
+  if (skill.diagnostics.length > 0) {
+    process.stdout.write("diagnostics:\n");
+    for (const diag of skill.diagnostics) process.stdout.write(`  ${diag.type}: ${diag.message}
+`);
+  }
+}
+function formatMarketplaceOrigin(skill) {
+  const parts = [skill.origin === "catalog" ? "catalog" : "index"];
+  if (skill.version) parts.push(`v${skill.version}`);
+  if (skill.audit) parts.push(`audit: ${skill.audit}`);
+  return parts.join(", ");
+}
+function validationLoad(pathArg) {
+  if (!pathArg) return loadSkills({ cwd: process.cwd() });
+  return loadSkills({ disableDiscovery: true, explicitSkillPaths: [resolve(pathArg)] });
+}
+async function runSkillsCommand(argv) {
+  let parsed;
+  try {
+    parsed = parse(argv);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help || !parsed.command) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  switch (parsed.command) {
+    case "list": {
+      const list = loadSkills({ cwd: process.cwd() });
+      const skills = parsed.all ? list.items : modelVisibleSkills(list.items);
+      if (parsed.json) process.stdout.write(`${JSON.stringify({ skills, diagnostics: list.diagnostics }, null, 2)}
+`);
+      else {
+        printList(skills);
+        printDiagnostics(list.diagnostics);
+      }
+      return list.diagnostics.some((diag) => diag.type === "error") ? 1 : 0;
+    }
+    case "search": {
+      const query = parsed.positional.join(" ").trim().toLowerCase();
+      if (query.length === 0) {
+        process.stderr.write("usage: clio-coder skills search <query> [--json]\n");
+        return 2;
+      }
+      const list = loadSkills({ cwd: process.cwd() });
+      const discovery = discoverMarketplaceSkills({ cwd: process.cwd() });
+      const installedNames = new Set(list.items.map((skill) => skill.name));
+      const matchesQuery = (name, description) => name.toLowerCase().includes(query) || description.toLowerCase().includes(query);
+      const installed = list.items.filter((skill) => matchesQuery(skill.name, skill.description));
+      const marketplace = discovery.skills.filter(
+        (skill) => !installedNames.has(skill.name) && (matchesQuery(skill.name, skill.description) || skill.category?.toLowerCase() === query)
+      );
+      const exitCode = list.diagnostics.some((diag) => diag.type === "error") ? 1 : 0;
+      if (parsed.json) {
+        process.stdout.write(
+          `${JSON.stringify(
+            { query, installed, marketplace, diagnostics: list.diagnostics, marketplaceDiagnostics: discovery.diagnostics },
+            null,
+            2
+          )}
+`
+        );
+        return exitCode;
+      }
+      if (installed.length > 0) {
+        process.stdout.write("installed:\n");
+        for (const skill of installed) {
+          process.stdout.write(`  ${skill.name.padEnd(24)} ${skill.description}  (${skill.scope}/${skill.source})
+`);
+        }
+      }
+      if (marketplace.length > 0) {
+        process.stdout.write("marketplace (clio-coder skills install <name>):\n");
+        for (const skill of marketplace) {
+          process.stdout.write(`  ${skill.name.padEnd(24)} ${skill.description}  (${formatMarketplaceOrigin(skill)})
+`);
+        }
+      }
+      if (installed.length === 0 && marketplace.length === 0) {
+        process.stdout.write(`skills: no matches for "${query}"
+`);
+      }
+      printDiagnostics(list.diagnostics);
+      for (const message of discovery.diagnostics) process.stderr.write(`warning: ${message}
+`);
+      return exitCode;
+    }
+    case "inspect": {
+      const name = parsed.positional[0];
+      if (!name || parsed.positional.length !== 1) {
+        process.stderr.write("usage: clio-coder skills inspect <name> [--json]\n");
+        return 2;
+      }
+      const list = loadSkills({ cwd: process.cwd() });
+      const skill = list.items.find((entry) => entry.name === name);
+      if (!skill) {
+        const available = discoverMarketplaceSkills({ cwd: process.cwd() }).skills.some((entry) => entry.name === name);
+        printError(
+          available ? `skill not installed: ${name} (available in the marketplace; install it with: clio-coder skills install ${name})` : `unknown skill: ${name}`
+        );
+        return 1;
+      }
+      if (parsed.json) process.stdout.write(`${JSON.stringify({ skill }, null, 2)}
+`);
+      else printInspect(skill);
+      return 0;
+    }
+    case "validate": {
+      const pathArg = parsed.positional[0];
+      if (parsed.positional.length > 1) {
+        process.stderr.write("usage: clio-coder skills validate [path] [--json]\n");
+        return 2;
+      }
+      const list = validationLoad(pathArg);
+      const loadedPaths = new Set(list.items.map((skill) => skill.filePath));
+      const hasInvalidDiagnostic = list.diagnostics.some(
+        (diag) => diag.type === "error" || diag.type === "collision" || diag.type === "warning" && diag.path !== void 0 && !loadedPaths.has(diag.path)
+      );
+      const ok = list.items.length > 0 && !hasInvalidDiagnostic;
+      if (parsed.json) {
+        process.stdout.write(`${JSON.stringify({ ok, skills: list.items, diagnostics: list.diagnostics }, null, 2)}
+`);
+      } else {
+        printDiagnostics(list.diagnostics);
+        process.stdout.write(`${ok ? "valid" : "invalid"}: ${list.items.length} skill(s)
+`);
+      }
+      return ok ? 0 : 1;
+    }
+    case "install": {
+      let sources = parsed.positional;
+      if (parsed.category !== void 0) {
+        if (sources.length > 0) {
+          process.stderr.write("--category installs a whole catalog group; do not also name skills\n");
+          return 2;
+        }
+        const grouped = discoverMarketplaceSkills().skills.filter((skill) => skill.category === parsed.category);
+        if (grouped.length === 0) {
+          printError(`no marketplace skills in category "${parsed.category}"`);
+          return 1;
+        }
+        sources = grouped.map((skill) => skill.name);
+      }
+      if (sources.length === 0) {
+        process.stderr.write(
+          "usage: clio-coder skills install <name|path|github-url>... [--user|--project] [--name <name>] [--force]\n       clio-coder skills install --category <category> [--user|--project] [--force]\n"
+        );
+        return 2;
+      }
+      if (parsed.name !== void 0 && sources.length !== 1) {
+        process.stderr.write("--name applies to a single skill; install them one at a time to rename\n");
+        return 2;
+      }
+      let failed = 0;
+      for (const source of sources) {
+        try {
+          const result = installSkill({
+            source,
+            scope: parsed.scope ?? "project",
+            force: parsed.force,
+            ...parsed.name ? { name: parsed.name } : {}
+          });
+          printOk(`installed ${result.scope} skill ${result.name} at ${result.path}`);
+          for (const warning of result.warnings) process.stderr.write(`warning: ${warning}
+`);
+        } catch (err) {
+          failed += 1;
+          printError(err instanceof Error ? err.message : String(err));
+        }
+      }
+      if (failed === sources.length) return 1;
+      process.stdout.write("audit is set to unknown; review the skill and set audit: pass yourself\n");
+      return failed > 0 ? 1 : 0;
+    }
+    case "update": {
+      const name = parsed.positional[0];
+      if (!name && !parsed.all || parsed.positional.length > 1) {
+        process.stderr.write("usage: clio-coder skills update <name> | --all [--force]\n");
+        return 2;
+      }
+      try {
+        const reports = updateSkills(name ? { name, force: parsed.force } : { all: true, force: parsed.force });
+        return printUpdateReports(reports);
+      } catch (err) {
+        printError(err instanceof Error ? err.message : String(err));
+        return 1;
+      }
+    }
+    case "sync": {
+      try {
+        return printUpdateReports(updateSkills({ all: true, force: parsed.force }));
+      } catch (err) {
+        printError(err instanceof Error ? err.message : String(err));
+        return 1;
+      }
+    }
+    case "eval": {
+      const name = parsed.positional[0];
+      if (!name || parsed.positional.length !== 1) {
+        process.stderr.write(
+          "usage: clio-coder skills eval <name|path> [--scenario <id>] [--target <id>] [--workspace <path>] [--timeout <seconds>] [--trust-fixtures] [--allow-network] [--json]\n"
+        );
+        return 2;
+      }
+      const { runSkillsEvalCommand } = await import("./skills-eval-E2ZTW4PL.js");
+      return runSkillsEvalCommand(name, {
+        json: parsed.json,
+        trustFixtures: parsed.trustFixtures,
+        allowNetwork: parsed.allowNetwork,
+        ...parsed.scenario !== void 0 ? { scenario: parsed.scenario } : {},
+        ...parsed.target !== void 0 ? { target: parsed.target } : {},
+        ...parsed.workspace !== void 0 ? { workspace: parsed.workspace } : {},
+        ...parsed.timeoutSeconds !== void 0 ? { timeoutSeconds: parsed.timeoutSeconds } : {}
+      });
+    }
+    default:
+      printError(`unknown skills command: ${parsed.command}`);
+      process.stderr.write(HELP);
+      return 2;
+  }
+}
+export {
+  runSkillsCommand
+};
+//# sourceMappingURL=skills-F2MRLELY.js.map