@iowarp/clio-coder 0.3.0

package/dist/chunk-2J63S4SF.js

@@ -0,0 +1,508 @@
+import {
+  defaultScopedResourceRoots,
+  expandSkillInvocationInput,
+  loadSkills,
+  parsePendingSkillRequests,
+  readRootEntries,
+  sourceInfoForRoot,
+  splitYamlFrontmatter,
+  stringField
+} from "./chunk-26BZQOAD.js";
+import {
+  expandConfigPath
+} from "./chunk-5LDRNKX2.js";
+
+// src/domains/resources/skills/evals.ts
+var SCENARIO_HEADING = /^##\s+([A-Z])(\d+)\s*[-:–—]\s*(.+?)\s*$/;
+function parseSkillEvals(markdown) {
+  const lines = markdown.split("\n");
+  const scenarios = [];
+  const diagnostics = [];
+  let index = 0;
+  while (index < lines.length) {
+    const heading = SCENARIO_HEADING.exec(lines[index] ?? "");
+    if (heading === null) {
+      index += 1;
+      continue;
+    }
+    const blockStart = index + 1;
+    let blockEnd = blockStart;
+    while (blockEnd < lines.length && !/^##\s+/.test(lines[blockEnd] ?? "")) blockEnd += 1;
+    const block = lines.slice(blockStart, blockEnd);
+    const number = Number.parseInt(heading[2] ?? "", 10);
+    const id = `${heading[1] ?? "S"}${number}`;
+    const title = heading[3] ?? "";
+    const setup = extractSetup(block);
+    const fixtureCommands = extractFixtureCommands(block);
+    const expected = extractExpected(block);
+    if (setup === null) diagnostics.push(`${id} (${title}): no "Setup:" or "Prompt:" paragraph found; scenario skipped`);
+    else if (expected.length === 0) diagnostics.push(`${id} (${title}): no "Expected:" bullets found; scenario skipped`);
+    else scenarios.push({ id, number, title, setup, ...fixtureCommands ? { fixtureCommands } : {}, expected });
+    index = blockEnd;
+  }
+  return { scenarios, diagnostics };
+}
+function extractSetup(block) {
+  return extractLabeledParagraph(block, /^Setup:\s*(.*)$/i) ?? extractLabeledParagraph(block, /^(Prompt:.*)$/i);
+}
+function isScenarioLabel(line) {
+  const trimmed = line.trim();
+  return /^(Expected|Fixture|Setup commands):/i.test(trimmed) || /^Expected$/i.test(trimmed);
+}
+function extractLabeledParagraph(block, label) {
+  for (let i = 0; i < block.length; i += 1) {
+    const line = block[i] ?? "";
+    const match = label.exec(line.trim());
+    if (match === null) continue;
+    const parts = [];
+    if ((match[1] ?? "").length > 0) parts.push(match[1] ?? "");
+    for (let j = i + 1; j < block.length; j += 1) {
+      const next = (block[j] ?? "").trim();
+      if (next.length === 0) break;
+      if (isScenarioLabel(next)) break;
+      parts.push(next);
+    }
+    const setup = parts.join(" ").trim();
+    return setup.length > 0 ? setup : null;
+  }
+  return null;
+}
+function extractFixtureCommands(block) {
+  for (let i = 0; i < block.length; i += 1) {
+    const line = (block[i] ?? "").trim();
+    const match = /^(?:Fixture|Setup commands):\s*(.*)$/i.exec(line);
+    if (match === null) continue;
+    const inline = (match[1] ?? "").trim();
+    let cursor = i + 1;
+    while (cursor < block.length && (block[cursor] ?? "").trim().length === 0) cursor += 1;
+    const first = block[cursor] ?? "";
+    const fence = /^```\w*\s*$/.test(first.trim());
+    if (fence) {
+      const commands2 = [];
+      for (let j = cursor + 1; j < block.length; j += 1) {
+        const current = block[j] ?? "";
+        if (/^```\s*$/.test(current.trim())) {
+          const script2 = commands2.join("\n").trim();
+          return script2.length > 0 ? script2 : null;
+        }
+        commands2.push(current);
+      }
+      return null;
+    }
+    const commands = [];
+    if (inline.length > 0) commands.push(inline);
+    for (let j = cursor; j < block.length; j += 1) {
+      const current = block[j] ?? "";
+      const trimmed = current.trim();
+      if (trimmed.length === 0) break;
+      if (isScenarioLabel(trimmed)) break;
+      commands.push(current);
+    }
+    const script = commands.join("\n").trim();
+    return script.length > 0 ? script : null;
+  }
+  return null;
+}
+function extractExpected(block) {
+  let start = -1;
+  for (let i = 0; i < block.length; i += 1) {
+    if (/^Expected:?\s*$/i.test((block[i] ?? "").trim())) {
+      start = i + 1;
+      break;
+    }
+  }
+  if (start < 0) return [];
+  const bullets = [];
+  let current = null;
+  for (let i = start; i < block.length; i += 1) {
+    const raw = block[i] ?? "";
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      if (current !== null) {
+        bullets.push(current.join(" "));
+        current = null;
+      }
+      continue;
+    }
+    const bullet = /^[-*]\s+(.*)$/.exec(raw);
+    if (bullet !== null) {
+      if (current !== null) bullets.push(current.join(" "));
+      current = [bullet[1] ?? ""];
+      continue;
+    }
+    if (current !== null && /^\s+\S/.test(raw)) {
+      current.push(trimmed);
+      continue;
+    }
+    break;
+  }
+  if (current !== null) bullets.push(current.join(" "));
+  return bullets.map((bullet) => bullet.trim()).filter((bullet) => bullet.length > 0);
+}
+
+// src/domains/resources/prompts/loader.ts
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+// src/domains/resources/collision.ts
+var SCOPE_RANK = {
+  package: 0,
+  user: 1,
+  project: 2,
+  cli: 3
+};
+function compareCandidates(a, b) {
+  const rankDelta = SCOPE_RANK[a.source.scope] - SCOPE_RANK[b.source.scope];
+  if (rankDelta !== 0) return rankDelta;
+  return a.source.path.localeCompare(b.source.path);
+}
+function resolveResourceCollisions(candidates) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const key = candidate.name.trim();
+    if (key.length === 0) continue;
+    const list = byName.get(key) ?? [];
+    list.push(candidate);
+    byName.set(key, list);
+  }
+  const winners = [];
+  const diagnostics = [];
+  for (const [name, entries] of byName.entries()) {
+    const sorted = [...entries].sort(compareCandidates);
+    const winner = sorted[sorted.length - 1];
+    if (!winner) continue;
+    winners.push(winner.value);
+    for (const loser of sorted.slice(0, -1)) {
+      diagnostics.push({
+        type: "collision",
+        message: `${name} from ${winner.source.scope} overrides ${loser.source.scope}`,
+        path: loser.source.path,
+        collision: {
+          name,
+          winnerPath: winner.source.path,
+          loserPath: loser.source.path,
+          winnerScope: winner.source.scope,
+          loserScope: loser.source.scope
+        }
+      });
+    }
+  }
+  return { winners, diagnostics };
+}
+
+// src/domains/resources/prompts/substitute.ts
+function parseCommandArgs(input) {
+  const args = [];
+  let current = "";
+  let hasToken = false;
+  let quote = null;
+  const push = () => {
+    if (!hasToken) return;
+    args.push(current);
+    current = "";
+    hasToken = false;
+  };
+  for (let i = 0; i < input.length; i += 1) {
+    const ch = input[i];
+    if (!ch) continue;
+    if (quote) {
+      if (ch === quote) {
+        quote = null;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === "'" || ch === `"`) {
+      quote = ch;
+      hasToken = true;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      push();
+      continue;
+    }
+    current += ch;
+    hasToken = true;
+  }
+  push();
+  return args;
+}
+function sliceArgs(args, startText, lengthText) {
+  const start = Number.parseInt(startText, 10);
+  if (!Number.isFinite(start) || start <= 0) return "";
+  const zeroBased = start - 1;
+  if (lengthText === void 0) return args.slice(zeroBased).join(" ");
+  const length = Number.parseInt(lengthText, 10);
+  if (!Number.isFinite(length) || length <= 0) return "";
+  return args.slice(zeroBased, zeroBased + length).join(" ");
+}
+function substituteArgs(content, args) {
+  const allArgs = args.join(" ");
+  return content.replace(
+    /\$\{@:(\d+)(?::(\d+))?\}/g,
+    (_match, start, length) => sliceArgs(args, start, length)
+  ).replace(/\$ARGUMENTS/g, allArgs).replace(/\$@/g, allArgs).replace(/\$(\d+)/g, (_match, indexText) => {
+    const index = Number.parseInt(indexText, 10);
+    if (!Number.isFinite(index) || index <= 0) return "";
+    return args[index - 1] ?? "";
+  });
+}
+
+// src/domains/resources/prompts/loader.ts
+function defaultPromptTemplateRoots(cwd) {
+  return defaultScopedResourceRoots("prompts", cwd);
+}
+function splitOptionalFrontmatter(raw, filePath, diagnostics) {
+  const split = splitYamlFrontmatter(raw);
+  if (split.ok) return split;
+  if (split.reason === "missing") return { frontmatter: {}, body: raw };
+  const message = split.reason === "missing closing delimiter" ? "prompt template frontmatter is missing a closing delimiter; treating the file as plain markdown" : split.reason === "must be a YAML object" ? "prompt template frontmatter must be a YAML object" : `prompt template frontmatter is ${split.reason}`;
+  diagnostics.push({ type: "warning", message, path: filePath });
+  return { frontmatter: {}, body: split.body };
+}
+function fallbackDescription(body) {
+  const line = body.split(/\r?\n/).map((entry) => entry.trim()).find((entry) => entry.length > 0);
+  if (!line) return "Prompt template";
+  const normalized = line.replace(/^#{1,6}\s+/, "");
+  return normalized.length > 60 ? `${normalized.slice(0, 57)}...` : normalized;
+}
+function loadPromptFile(filePath, root, diagnostics) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (ext !== ".md") return null;
+  let raw;
+  try {
+    raw = readFileSync(filePath, "utf8");
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    diagnostics.push({ type: "warning", message: `prompt template could not be read: ${reason}`, path: filePath });
+    return null;
+  }
+  const name = path.basename(filePath, ext);
+  if (name.trim().length === 0) return null;
+  const { frontmatter, body } = splitOptionalFrontmatter(raw, filePath, diagnostics);
+  const description = stringField(frontmatter, "description") ?? fallbackDescription(body);
+  const argumentHint = stringField(frontmatter, "argument-hint") ?? stringField(frontmatter, "argumentHint");
+  const sourceInfo = sourceInfoForRoot(root, filePath);
+  const template = {
+    name,
+    description,
+    content: body.trim(),
+    filePath,
+    sourceInfo
+  };
+  if (argumentHint) template.argumentHint = argumentHint;
+  return { name, value: template, source: sourceInfo };
+}
+function loadPromptRoot(root, diagnostics) {
+  const candidates = [];
+  for (const entry of readRootEntries(root, "prompt template", diagnostics)) {
+    if (!entry.isFile()) continue;
+    const candidate = loadPromptFile(path.join(root.path, entry.name), root, diagnostics);
+    if (candidate) candidates.push(candidate);
+  }
+  return candidates;
+}
+function loadPromptTemplates(input = {}) {
+  const cwd = input.cwd ?? process.cwd();
+  const roots = input.roots ?? defaultPromptTemplateRoots(cwd);
+  const diagnostics = [];
+  const candidates = roots.flatMap((root) => loadPromptRoot(root, diagnostics));
+  const resolved = resolveResourceCollisions(candidates);
+  return {
+    items: [...resolved.winners].sort((a, b) => a.name.localeCompare(b.name)),
+    diagnostics: [...diagnostics, ...resolved.diagnostics]
+  };
+}
+function parsePromptCommand(input) {
+  const trimmed = input.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const withoutSlash = trimmed.slice(1);
+  const separator = withoutSlash.search(/\s/);
+  const name = separator === -1 ? withoutSlash : withoutSlash.slice(0, separator);
+  if (name.length === 0 || name.includes("/")) return null;
+  const rest = separator === -1 ? "" : withoutSlash.slice(separator).trim();
+  return { name, rest };
+}
+function expandPromptTemplateInput(input, templates) {
+  const command = parsePromptCommand(input);
+  if (!command) return { expanded: false, text: input, args: [], diagnostics: templates.diagnostics };
+  const template = templates.items.find((entry) => entry.name === command.name);
+  if (!template) return { expanded: false, text: input, args: [], diagnostics: templates.diagnostics };
+  const args = parseCommandArgs(command.rest);
+  return {
+    expanded: true,
+    text: substituteArgs(template.content, args),
+    args,
+    template,
+    diagnostics: templates.diagnostics
+  };
+}
+
+// src/domains/resources/loader.ts
+function createResourcesLoader(options = {}) {
+  const defaultCwd = options.cwd ?? process.cwd();
+  const skillOptions2 = () => options.skills?.() ?? {};
+  return {
+    skills(cwd = defaultCwd) {
+      return loadSkills({ cwd, ...skillOptions2() });
+    },
+    expandSkillInvocation(text, cwd = defaultCwd, expansionOptions = {}) {
+      return expandSkillInvocationInput(text, loadSkills({ cwd, ...skillOptions2() }), expansionOptions);
+    },
+    parsePendingSkillRequests(text, cwd = defaultCwd, expansionOptions = {}) {
+      return parsePendingSkillRequests(text, loadSkills({ cwd, ...skillOptions2() }), { cwd, ...expansionOptions });
+    },
+    prompts(cwd = defaultCwd) {
+      return loadPromptTemplates({ cwd });
+    },
+    expandPromptTemplate(text, cwd = defaultCwd) {
+      return expandPromptTemplateInput(text, loadPromptTemplates({ cwd }));
+    },
+    themes() {
+      return { items: [], diagnostics: [] };
+    },
+    resolvePath(value, cwd = defaultCwd) {
+      return expandConfigPath(value, { cwd });
+    },
+    async reload() {
+      return void 0;
+    }
+  };
+}
+
+// src/domains/resources/extension.ts
+function createResourcesBundle(context, options = {}) {
+  const config = () => context.getContract("config");
+  const loader = createResourcesLoader({
+    ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+    skills: () => ({
+      ...skillOptions(config()?.get().skills.trustProjectCompatRoots === true, options)
+    })
+  });
+  const extension = {
+    start() {
+      return void 0;
+    }
+  };
+  const contract = {
+    skills(cwd) {
+      return loader.skills(cwd);
+    },
+    expandSkillInvocation(text, cwd, options2) {
+      return loader.expandSkillInvocation(text, cwd, options2);
+    },
+    parsePendingSkillRequests(text, cwd, options2) {
+      return loader.parsePendingSkillRequests(text, cwd, options2);
+    },
+    prompts(cwd) {
+      return loader.prompts(cwd);
+    },
+    expandPromptTemplate(text, cwd) {
+      return loader.expandPromptTemplate(text, cwd);
+    },
+    themes() {
+      return loader.themes();
+    },
+    resolvePath(value, cwd) {
+      return loader.resolvePath(value, cwd);
+    },
+    reload() {
+      return loader.reload();
+    }
+  };
+  return { extension, contract };
+}
+function skillOptions(trustProjectCompatRoots, options) {
+  const runtime = options.skills?.() ?? {};
+  return {
+    trustProjectCompatRoots: runtime.trustProjectCompatRoots ?? trustProjectCompatRoots,
+    ...runtime.disableDiscovery !== void 0 ? { disableDiscovery: runtime.disableDiscovery } : {},
+    ...runtime.explicitSkillPaths !== void 0 ? { explicitSkillPaths: runtime.explicitSkillPaths } : {}
+  };
+}
+
+// src/domains/resources/manifest.ts
+var ResourcesManifest = {
+  name: "resources",
+  dependsOn: ["config"]
+};
+
+// src/domains/resources/skills/provenance-pin.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import path2 from "node:path";
+import yaml from "yaml";
+var SKILL_PIN_MANIFEST_FILENAME = "registry.yaml";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveSkillPinManifestPath(cwd) {
+  const fromEnv = process.env.CLIO_CODER_SKILL_CATALOG_DIR;
+  const catalogDir = fromEnv && fromEnv.trim().length > 0 ? path2.resolve(fromEnv.trim()) : path2.join(cwd, "skills");
+  const manifestPath = path2.join(catalogDir, SKILL_PIN_MANIFEST_FILENAME);
+  return existsSync(manifestPath) ? manifestPath : null;
+}
+function loadSkillPinManifest(manifestPath) {
+  let parsed;
+  try {
+    parsed = yaml.parse(readFileSync2(manifestPath, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!isPlainObject(parsed) || !Array.isArray(parsed.skills)) return null;
+  const entries = /* @__PURE__ */ new Map();
+  for (const raw of parsed.skills) {
+    if (!isPlainObject(raw)) continue;
+    const name = typeof raw.name === "string" ? raw.name.trim() : "";
+    const sha256 = typeof raw.sha256 === "string" ? raw.sha256.trim().toLowerCase() : "";
+    if (name.length === 0 || !/^[0-9a-f]{64}$/.test(sha256)) continue;
+    entries.set(name, {
+      name,
+      version: typeof raw.version === "string" && raw.version.trim().length > 0 ? raw.version.trim() : null,
+      sha256
+    });
+  }
+  return entries;
+}
+function checkSkillDrift(skill, cwd) {
+  const actual = skill.normalizedHash.toLowerCase();
+  const manifestPath = resolveSkillPinManifestPath(cwd);
+  const manifest = manifestPath === null ? null : loadSkillPinManifest(manifestPath);
+  const pinned = manifest?.get(skill.name);
+  if (pinned !== void 0) {
+    return {
+      verdict: pinned.sha256 === actual ? "match" : "mismatch",
+      authority: "pinned-manifest",
+      expected: pinned.sha256
+    };
+  }
+  const recorded = skill.provenance?.installedHash?.trim().toLowerCase();
+  if (recorded !== void 0 && /^[0-9a-f]{64}$/.test(recorded)) {
+    return {
+      verdict: recorded === actual ? "match" : "mismatch",
+      authority: "install-record",
+      expected: recorded
+    };
+  }
+  return null;
+}
+
+// src/domains/resources/index.ts
+var ResourcesDomainModule = {
+  manifest: ResourcesManifest,
+  createExtension: createResourcesBundle
+};
+function createResourcesDomainModule(options = {}) {
+  return {
+    manifest: ResourcesManifest,
+    createExtension: (context) => createResourcesBundle(context, options)
+  };
+}
+
+export {
+  parseSkillEvals,
+  checkSkillDrift,
+  ResourcesDomainModule,
+  createResourcesDomainModule
+};
+//# sourceMappingURL=chunk-2J63S4SF.js.map