@agntk/agent-harness 0.1.1

package/dist/universal-installer-QGS4SJGX.js

@@ -0,0 +1,578 @@
+#!/usr/bin/env node
+
+import {
+  discoverSources
+} from "./chunk-RC6MEZB6.js";
+import {
+  downloadCapability,
+  fixCapability,
+  installCapability
+} from "./chunk-W4T7PGI2.js";
+import "./chunk-4FDUOGSZ.js";
+import "./chunk-Z2PUCXTZ.js";
+import "./chunk-UPLBF4RZ.js";
+import "./chunk-BSKDOFRT.js";
+import "./chunk-4CWAGBNS.js";
+import "./chunk-ZZJOFKAT.js";
+
+// src/runtime/universal-installer.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from "fs";
+import { join, basename, extname } from "path";
+import { tmpdir } from "os";
+import matter from "gray-matter";
+import { parse as parseYaml } from "yaml";
+var VALID_TYPES = ["rule", "instinct", "skill", "playbook", "workflow", "tool", "agent"];
+var TYPE_DIRS = {
+  rule: "rules",
+  instinct: "instincts",
+  skill: "skills",
+  playbook: "playbooks",
+  workflow: "workflows",
+  tool: "tools",
+  agent: "agents"
+};
+function detectFormat(content, filename) {
+  const ext = extname(filename).toLowerCase();
+  const reasons = [];
+  let format = "unknown";
+  let primitiveType = null;
+  let confidence = 0;
+  if (ext === ".sh" || ext === ".bash" || content.trimStart().startsWith("#!/")) {
+    format = "bash-hook";
+    primitiveType = "workflow";
+    confidence = 0.9;
+    reasons.push("Shell script detected (shebang or .sh extension)");
+    if (content.includes("hook") || content.includes("pre-commit") || content.includes("post-")) {
+      primitiveType = "workflow";
+      reasons.push("Hook pattern detected in content");
+    }
+    return { format, primitiveType, confidence, reasons };
+  }
+  if (ext === ".json") {
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed.mcpServers || parsed.servers || parsed.command || parsed.args) {
+        format = "mcp-config";
+        primitiveType = "tool";
+        confidence = 0.9;
+        reasons.push("MCP configuration JSON detected");
+        return { format, primitiveType, confidence, reasons };
+      }
+    } catch {
+    }
+  }
+  if (ext === ".faf" || ext === ".yaml" || ext === ".yml") {
+    try {
+      const parsed = parseYaml(content);
+      if (parsed.type && parsed.content) {
+        format = "faf-yaml";
+        primitiveType = inferTypeFromFafType(String(parsed.type));
+        confidence = 0.9;
+        reasons.push(`.faf YAML format with type: ${parsed.type}`);
+        return { format, primitiveType, confidence, reasons };
+      }
+      if (parsed.mcpServers || parsed.servers) {
+        format = "mcp-config";
+        primitiveType = "tool";
+        confidence = 0.85;
+        reasons.push("MCP configuration YAML detected");
+        return { format, primitiveType, confidence, reasons };
+      }
+    } catch {
+    }
+  }
+  if (ext === ".md" || ext === "" || !ext) {
+    try {
+      const parsed = matter(content);
+      const data = parsed.data;
+      if (data.id && data.status) {
+        format = "harness";
+        confidence = 0.95;
+        reasons.push("Harness frontmatter detected (id + status fields)");
+        const tags = Array.isArray(data.tags) ? data.tags.map((t) => String(t).toLowerCase()) : [];
+        for (const type of VALID_TYPES) {
+          if (tags.includes(type)) {
+            primitiveType = type;
+            break;
+          }
+        }
+        return { format, primitiveType, confidence, reasons };
+      }
+      if (Object.keys(data).length > 0) {
+        format = "raw-markdown";
+        confidence = 0.7;
+        reasons.push("Markdown with non-harness frontmatter");
+      }
+    } catch {
+    }
+    if (format === "unknown" || format === "raw-markdown") {
+      const isClaudeSkill = detectClaudeSkillPattern(content, filename);
+      if (isClaudeSkill) {
+        format = "claude-skill";
+        primitiveType = "skill";
+        confidence = 0.8;
+        reasons.push("Claude Code SKILL.md pattern detected");
+        return { format, primitiveType, confidence, reasons };
+      }
+    }
+    if (format === "unknown") {
+      format = "raw-markdown";
+      confidence = 0.5;
+      reasons.push("Plain markdown without frontmatter");
+    }
+    if (!primitiveType) {
+      primitiveType = inferTypeFromContent(content, filename);
+      if (primitiveType) {
+        reasons.push(`Type inferred from content/filename: ${primitiveType}`);
+      }
+    }
+    return { format, primitiveType, confidence, reasons };
+  }
+  return { format, primitiveType, confidence, reasons };
+}
+function normalizeToHarness(content, filename, detection, options) {
+  const fixes = [];
+  const type = options?.type ?? detection.primitiveType;
+  switch (detection.format) {
+    case "harness":
+      return { content, filename, fixes: ["Already in harness format"] };
+    case "claude-skill":
+      return normalizeClaudeSkill(content, filename, type, options, fixes);
+    case "faf-yaml":
+      return normalizeFafYaml(content, filename, type, options, fixes);
+    case "raw-markdown":
+      return normalizeRawMarkdown(content, filename, type, options, fixes);
+    case "bash-hook":
+      return normalizeBashHook(content, filename, type, options, fixes);
+    case "mcp-config":
+      return normalizeMcpConfig(content, filename, options, fixes);
+    default:
+      return normalizeRawMarkdown(content, filename, type, options, fixes);
+  }
+}
+function normalizeClaudeSkill(content, filename, type, options, fixes) {
+  const id = options?.id ?? deriveId(filename);
+  const primitiveType = type ?? "skill";
+  const tags = [primitiveType, ...options?.tags ?? []];
+  const headingMatch = content.match(/^#\s+(.+)$/m);
+  const title = headingMatch ? headingMatch[1].trim() : id;
+  const frontmatter = {
+    id,
+    created: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    author: "human",
+    status: "active",
+    tags
+  };
+  const l0 = title.length > 120 ? title.slice(0, 117) + "..." : title;
+  const paragraphs = content.split(/\n{2,}/).filter((p) => {
+    const trimmed = p.trim();
+    return trimmed.length > 0 && !trimmed.startsWith("#") && !trimmed.startsWith("<!--");
+  });
+  const l1 = paragraphs.length > 0 ? paragraphs[0].replace(/\n/g, " ").trim().slice(0, 300) : "";
+  let body = `<!-- L0: ${l0} -->
+`;
+  if (l1) {
+    body += `<!-- L1: ${l1} -->
+`;
+  }
+  body += "\n" + content;
+  const result = matter.stringify(body, frontmatter);
+  fixes.push("Added harness frontmatter (id, status, tags)");
+  fixes.push(`Generated L0 from heading: "${l0}"`);
+  if (l1) fixes.push("Generated L1 from first paragraph");
+  const outFilename = ensureMdExtension(filename);
+  return { content: result, filename: outFilename, fixes };
+}
+function normalizeFafYaml(content, filename, type, options, fixes) {
+  let parsed;
+  try {
+    parsed = parseYaml(content);
+  } catch {
+    fixes.push("Failed to parse YAML \u2014 treating as raw markdown");
+    return normalizeRawMarkdown(content, filename, type, options, fixes);
+  }
+  const id = options?.id ?? String(parsed.id ?? deriveId(filename));
+  const fafType = String(parsed.type ?? "skill");
+  const primitiveType = type ?? inferTypeFromFafType(fafType) ?? "skill";
+  const title = String(parsed.title ?? parsed.name ?? id);
+  const description = String(parsed.description ?? "");
+  const fafContent = String(parsed.content ?? "");
+  const fafTags = Array.isArray(parsed.tags) ? parsed.tags.map(String) : [];
+  const tags = [primitiveType, ...fafTags, ...options?.tags ?? []];
+  const frontmatter = {
+    id,
+    created: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    author: "human",
+    status: "active",
+    tags: [...new Set(tags)]
+  };
+  const l0 = title.length > 120 ? title.slice(0, 117) + "..." : title;
+  const l1 = description.length > 300 ? description.slice(0, 297) + "..." : description;
+  let body = `<!-- L0: ${l0} -->
+`;
+  if (l1) body += `<!-- L1: ${l1} -->
+`;
+  body += `
+# ${title}
+
+`;
+  if (description) body += `${description}
+
+`;
+  if (fafContent) body += fafContent + "\n";
+  const result = matter.stringify(body, frontmatter);
+  fixes.push("Converted .faf YAML to harness markdown");
+  fixes.push(`Added frontmatter (id: ${id}, type: ${primitiveType})`);
+  const outFilename = deriveId(filename) + ".md";
+  return { content: result, filename: outFilename, fixes };
+}
+function normalizeRawMarkdown(content, filename, type, options, fixes) {
+  const id = options?.id ?? deriveId(filename);
+  const primitiveType = type ?? "skill";
+  const tags = [primitiveType, ...options?.tags ?? []];
+  let parsed;
+  try {
+    parsed = matter(content);
+  } catch {
+    parsed = { data: {}, content, orig: "", excerpt: "", language: "", matter: "", stringify: () => "" };
+  }
+  const data = parsed.data;
+  if (options?.id || !data.id) {
+    data.id = id;
+    fixes.push(`Set id: "${id}"`);
+  }
+  if (!data.status) {
+    data.status = "active";
+    fixes.push('Added status: "active"');
+  }
+  if (!data.created) {
+    data.created = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    fixes.push("Added created date");
+  }
+  if (!data.author || !["human", "agent", "infrastructure"].includes(String(data.author))) {
+    data.author = "human";
+    fixes.push('Added author: "human"');
+  }
+  if (!Array.isArray(data.tags) || data.tags.length === 0) {
+    data.tags = [...new Set(tags)];
+    fixes.push(`Added tags: [${data.tags.join(", ")}]`);
+  }
+  let body = parsed.content;
+  const l0Regex = /<!--\s*L0:\s*(.*?)\s*-->/;
+  if (!l0Regex.test(body)) {
+    const headingMatch = body.match(/^#\s+(.+)$/m);
+    const firstLine = body.split("\n").find((line) => line.trim().length > 0);
+    const summary = headingMatch ? headingMatch[1].trim() : firstLine?.trim() ?? id;
+    const l0 = summary.length > 120 ? summary.slice(0, 117) + "..." : summary;
+    body = `<!-- L0: ${l0} -->
+${body}`;
+    fixes.push(`Generated L0: "${l0}"`);
+  }
+  const l1Regex = /<!--\s*L1:\s*([\s\S]*?)\s*-->/;
+  if (!l1Regex.test(body)) {
+    const paragraphs = body.split(/\n{2,}/).filter((p) => {
+      const trimmed = p.trim();
+      return trimmed.length > 0 && !trimmed.startsWith("<!--") && !trimmed.startsWith("#");
+    });
+    if (paragraphs.length > 0) {
+      const para = paragraphs[0].replace(/\n/g, " ").trim();
+      const l1 = para.length > 300 ? para.slice(0, 297) + "..." : para;
+      const l0Pos = body.indexOf("-->");
+      if (l0Pos !== -1) {
+        const insertPos = l0Pos + 3;
+        body = body.slice(0, insertPos) + `
+<!-- L1: ${l1} -->` + body.slice(insertPos);
+      } else {
+        body = `<!-- L1: ${l1} -->
+${body}`;
+      }
+      fixes.push("Generated L1 from first paragraph");
+    }
+  }
+  const result = matter.stringify(body, data);
+  const outFilename = ensureMdExtension(filename);
+  return { content: result, filename: outFilename, fixes };
+}
+function normalizeBashHook(content, filename, type, options, fixes) {
+  const id = options?.id ?? deriveId(filename);
+  const primitiveType = type ?? "workflow";
+  const tags = [primitiveType, "hook", ...options?.tags ?? []];
+  const commentLines = content.split("\n").filter((line) => line.startsWith("#") && !line.startsWith("#!")).map((line) => line.replace(/^#\s?/, "").trim()).filter((line) => line.length > 0);
+  const description = commentLines.length > 0 ? commentLines.slice(0, 3).join(" ") : `Bash hook: ${id}`;
+  const frontmatter = {
+    id,
+    created: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    author: "human",
+    status: "active",
+    tags: [...new Set(tags)]
+  };
+  const l0 = description.length > 120 ? description.slice(0, 117) + "..." : description;
+  let body = `<!-- L0: ${l0} -->
+
+`;
+  body += `# ${id}
+
+`;
+  body += `${description}
+
+`;
+  body += "```bash\n";
+  body += content;
+  if (!content.endsWith("\n")) body += "\n";
+  body += "```\n";
+  const result = matter.stringify(body, frontmatter);
+  fixes.push("Wrapped bash script in harness markdown");
+  fixes.push(`Added frontmatter (id: ${id}, type: ${primitiveType})`);
+  const outFilename = deriveId(filename) + ".md";
+  return { content: result, filename: outFilename, fixes };
+}
+function normalizeMcpConfig(content, filename, options, fixes) {
+  const id = options?.id ?? deriveId(filename);
+  const tags = ["tool", "mcp", ...options?.tags ?? []];
+  let config = {};
+  const ext = extname(filename).toLowerCase();
+  try {
+    if (ext === ".json") {
+      config = JSON.parse(content);
+    } else {
+      config = parseYaml(content);
+    }
+  } catch {
+    fixes.push("Failed to parse MCP config");
+  }
+  const serverName = String(config.name ?? config.command ?? id);
+  const description = String(config.description ?? `MCP server: ${serverName}`);
+  const frontmatter = {
+    id,
+    created: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    author: "human",
+    status: "active",
+    tags: [...new Set(tags)]
+  };
+  const l0 = description.length > 120 ? description.slice(0, 117) + "..." : description;
+  let body = `<!-- L0: ${l0} -->
+
+`;
+  body += `# MCP Server: ${serverName}
+
+`;
+  body += `${description}
+
+`;
+  body += "## Configuration\n\n";
+  body += "```json\n";
+  body += JSON.stringify(config, null, 2);
+  body += "\n```\n";
+  const result = matter.stringify(body, frontmatter);
+  fixes.push("Converted MCP config to harness tool documentation");
+  fixes.push(`Added frontmatter (id: ${id})`);
+  const outFilename = deriveId(filename) + ".md";
+  return { content: result, filename: outFilename, fixes };
+}
+async function resolveSource(source, harnessDir) {
+  if (existsSync(source)) {
+    return { localPath: source, originalSource: source };
+  }
+  if (source.startsWith("https://") || source.startsWith("http://")) {
+    const rawUrl = convertToRawUrl(source);
+    const result = await downloadCapability(rawUrl);
+    if (result.downloaded) {
+      return { localPath: result.localPath, originalSource: source };
+    }
+    return { localPath: "", originalSource: source, error: result.error };
+  }
+  const results = discoverSources(harnessDir, source, { maxResults: 1 });
+  if (results.length > 0) {
+    const hit = results[0];
+    if (hit.source.type === "github") {
+      const rawUrl = convertToRawUrl(hit.url);
+      const result = await downloadCapability(rawUrl);
+      if (result.downloaded) {
+        return { localPath: result.localPath, originalSource: source };
+      }
+      return { localPath: "", originalSource: source, error: result.error };
+    }
+    return { localPath: "", originalSource: source, error: `Source "${hit.source.name}" is type "${hit.source.type}" \u2014 direct install not yet supported for this type` };
+  }
+  return { localPath: "", originalSource: source, error: `Could not resolve "${source}" \u2014 not a local file, URL, or known source` };
+}
+async function universalInstall(harnessDir, source, options) {
+  const result = {
+    installed: false,
+    source,
+    format: { format: "unknown", primitiveType: null, confidence: 0, reasons: [] },
+    destination: "",
+    fixes: [],
+    errors: [],
+    suggestedDependencies: []
+  };
+  const resolved = await resolveSource(source, harnessDir);
+  if (resolved.error || !resolved.localPath) {
+    result.errors.push(resolved.error ?? "Failed to resolve source");
+    return result;
+  }
+  let content;
+  try {
+    content = readFileSync(resolved.localPath, "utf-8");
+  } catch (err) {
+    result.errors.push(`Failed to read file: ${err instanceof Error ? err.message : String(err)}`);
+    return result;
+  }
+  if (content.trim().length === 0) {
+    result.errors.push("File is empty");
+    return result;
+  }
+  const filename = basename(resolved.localPath);
+  const detection = detectFormat(content, filename);
+  result.format = detection;
+  const normalized = normalizeToHarness(content, filename, detection, options);
+  result.fixes.push(...normalized.fixes);
+  const tempDir = join(tmpdir(), "harness-install");
+  mkdirSync(tempDir, { recursive: true });
+  const tempPath = join(tempDir, normalized.filename);
+  writeFileSync(tempPath, normalized.content, "utf-8");
+  if (!options?.skipFix) {
+    const fixResult = fixCapability(tempPath);
+    result.fixes.push(...fixResult.fixes_applied);
+    if (!fixResult.valid && !options?.force) {
+      result.errors.push(...fixResult.errors);
+      return result;
+    }
+  }
+  const installResult = installCapability(harnessDir, tempPath);
+  result.installed = installResult.installed;
+  result.destination = installResult.destination;
+  if (!installResult.installed) {
+    result.errors.push(...installResult.evalResult.errors);
+    if (options?.force && detection.primitiveType) {
+      const targetDir = join(harnessDir, TYPE_DIRS[detection.primitiveType] ?? "skills");
+      if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
+      const dest = join(targetDir, normalized.filename);
+      copyFileSync(tempPath, dest);
+      result.installed = true;
+      result.destination = dest;
+      result.fixes.push("Force-installed despite validation errors");
+    }
+  }
+  result.suggestedDependencies = extractDependencyHints(normalized.content);
+  return result;
+}
+async function installFromUrl(harnessDir, url, options) {
+  return universalInstall(harnessDir, url, options);
+}
+async function installFromFile(harnessDir, filePath, options) {
+  return universalInstall(harnessDir, filePath, options);
+}
+function deriveId(filename) {
+  const base = basename(filename).replace(/\.(md|faf|yaml|yml|json|sh|bash)$/i, "");
+  return base.replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+}
+function ensureMdExtension(filename) {
+  if (filename.endsWith(".md")) return filename;
+  return deriveId(filename) + ".md";
+}
+function convertToRawUrl(url) {
+  if (url.includes("raw.githubusercontent.com")) return url;
+  const blobMatch = url.match(
+    /^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/(.+)$/
+  );
+  if (blobMatch) {
+    const [, owner, repo, rest] = blobMatch;
+    return `https://raw.githubusercontent.com/${owner}/${repo}/${rest}`;
+  }
+  return url;
+}
+function detectClaudeSkillPattern(content, filename) {
+  const nameLower = filename.toLowerCase();
+  if (nameLower === "skill.md" || nameLower.endsWith("-skill.md") || nameLower.endsWith("_skill.md")) {
+    return true;
+  }
+  const patterns = [
+    /^#\s+.+skill/im,
+    /instructions?\s+for\s+/i,
+    /when\s+(the\s+)?user\s+(asks?|wants?|needs?|requests?)/i,
+    /you\s+(should|must|will)\s+/i
+  ];
+  let matches = 0;
+  for (const pattern of patterns) {
+    if (pattern.test(content)) matches++;
+  }
+  return matches >= 2 && !content.startsWith("---");
+}
+function inferTypeFromFafType(fafType) {
+  const typeMap = {
+    skill: "skill",
+    agent: "agent",
+    rule: "rule",
+    playbook: "playbook",
+    workflow: "workflow",
+    tool: "tool",
+    instinct: "instinct",
+    hook: "workflow",
+    template: "skill",
+    plugin: "skill"
+  };
+  return typeMap[fafType.toLowerCase()] ?? null;
+}
+function inferTypeFromContent(content, filename) {
+  const lower = content.toLowerCase();
+  const nameLower = filename.toLowerCase();
+  if (nameLower.includes("rule")) return "rule";
+  if (nameLower.includes("agent")) return "agent";
+  if (nameLower.includes("playbook")) return "playbook";
+  if (nameLower.includes("workflow")) return "workflow";
+  if (nameLower.includes("instinct")) return "instinct";
+  if (nameLower.includes("tool")) return "tool";
+  if (nameLower.includes("skill")) return "skill";
+  if (lower.includes("# rule:") || lower.includes("## rules")) return "rule";
+  if (lower.includes("# agent:") || lower.includes("## agent")) return "agent";
+  if (lower.includes("# playbook:") || lower.includes("## playbook")) return "playbook";
+  if (lower.includes("# skill:") || lower.includes("## skill")) return "skill";
+  if (lower.includes("# workflow:") || lower.includes("## workflow")) return "workflow";
+  if (lower.includes("# tool:") || lower.includes("## tool")) return "tool";
+  return null;
+}
+function extractDependencyHints(content) {
+  const hints = [];
+  const seen = /* @__PURE__ */ new Set();
+  try {
+    const parsed = matter(content);
+    const data = parsed.data;
+    if (Array.isArray(data.requires)) {
+      for (const dep of data.requires) {
+        if (!seen.has(dep)) {
+          hints.push(dep);
+          seen.add(dep);
+        }
+      }
+    }
+    if (Array.isArray(data.depends)) {
+      for (const dep of data.depends) {
+        if (!seen.has(dep)) {
+          hints.push(dep);
+          seen.add(dep);
+        }
+      }
+    }
+    if (Array.isArray(data.related)) {
+      for (const dep of data.related) {
+        if (!seen.has(dep)) {
+          hints.push(dep);
+          seen.add(dep);
+        }
+      }
+    }
+  } catch {
+  }
+  return hints;
+}
+export {
+  convertToRawUrl,
+  detectFormat,
+  installFromFile,
+  installFromUrl,
+  normalizeToHarness,
+  resolveSource,
+  universalInstall
+};
+//# sourceMappingURL=universal-installer-QGS4SJGX.js.map