modelfunction-cli 0.0.0-stage → 0.1.0

package/lib/suite.js

@@ -0,0 +1,117 @@
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+const EMPTY_SCHEMA = { type: "object", properties: {} };
+
+export async function loadSuite(suitePath, { allowEmptyCases = false } = {}) {
+  const abs = resolve(suitePath);
+  const raw = JSON.parse(await readFile(abs, "utf8"));
+  if (!Array.isArray(raw.tools) || raw.tools.length === 0) {
+    throw new Error(`suite ${abs}: "tools" must be a non-empty array`);
+  }
+  if (!Array.isArray(raw.cases) || (raw.cases.length === 0 && !allowEmptyCases)) {
+    throw new Error(`suite ${abs}: "cases" must be a non-empty array`);
+  }
+
+  const baseDir = dirname(abs);
+  const tools = await Promise.all(raw.tools.map((entry) => normalizeTool(entry, baseDir)));
+  const seen = new Set();
+  for (const tool of tools) {
+    if (seen.has(tool.name)) throw new Error(`suite ${abs}: duplicate tool "${tool.name}"`);
+    seen.add(tool.name);
+  }
+
+  const cases = raw.cases.map((entry, index) => normalizeCase(entry, index, seen));
+  return {
+    name: raw.name ?? "unnamed",
+    description: raw.description ?? "",
+    path: abs,
+    tools,
+    cases,
+    execution:
+      raw.execution && typeof raw.execution === "object" && !Array.isArray(raw.execution)
+        ? { ...raw.execution }
+        : null
+  };
+}
+
+async function normalizeTool(entry, baseDir) {
+  if (entry.ref) {
+    const specPath = resolve(baseDir, entry.ref);
+    const spec = JSON.parse(await readFile(specPath, "utf8"));
+    return {
+      name: requireString(spec.name, `tool ${specPath}: "name"`),
+      description: spec.description ?? "",
+      parameters: spec.input ?? spec.parameters ?? EMPTY_SCHEMA,
+      source: specPath,
+      sideEffects: normalizeSideEffects(spec.sideEffects ?? spec.side_effects)
+    };
+  }
+  return {
+    name: requireString(entry.name, "tool name"),
+    description: entry.description ?? "",
+    parameters: entry.parameters ?? entry.input ?? EMPTY_SCHEMA,
+    source: null,
+    sideEffects: normalizeSideEffects(entry.sideEffects ?? entry.side_effects)
+  };
+}
+
+function normalizeCase(entry, index, toolNames) {
+  const id = entry.id ?? `case_${index + 1}`;
+  if (typeof entry.input !== "string" || entry.input.trim() === "") {
+    throw new Error(`case ${id}: "input" must be a non-empty string`);
+  }
+  const expectedTool = entry.expectedTool ?? null;
+  if (expectedTool !== null && !toolNames.has(expectedTool)) {
+    throw new Error(`case ${id}: expectedTool "${expectedTool}" is not in the tool list`);
+  }
+  if (expectedTool === null && entry.expectedArgs && Object.keys(entry.expectedArgs).length > 0) {
+    throw new Error(`case ${id}: expectedArgs requires an expectedTool`);
+  }
+  const toolInput =
+    entry.toolInput && typeof entry.toolInput === "object" && !Array.isArray(entry.toolInput)
+      ? entry.toolInput
+      : null;
+  if (toolInput && expectedTool === null) {
+    throw new Error(`case ${id}: toolInput requires an expectedTool`);
+  }
+  return {
+    id,
+    input: entry.input,
+    expectedTool,
+    expectedArgs: entry.expectedArgs ?? {},
+    note: entry.note ?? "",
+    source: typeof entry.source === "string" && entry.source ? entry.source : "manual",
+    reviewed: entry.reviewed === undefined ? true : Boolean(entry.reviewed),
+    tags: Array.isArray(entry.tags) ? entry.tags.map(String) : [],
+    toolInput,
+    expect:
+      entry.expect && typeof entry.expect === "object" && !Array.isArray(entry.expect)
+        ? entry.expect
+        : null
+  };
+}
+
+function normalizeSideEffects(value) {
+  if (typeof value !== "string") return null;
+  const level = value.trim().toLowerCase();
+  return ["none", "read", "write", "external"].includes(level) ? level : null;
+}
+
+function requireString(value, label) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`${label} must be a non-empty string`);
+  }
+  return value.trim();
+}
+
+export function toModelTools(tools) {
+  return tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  }));
+}