@rowan-agent/agent 0.4.6 → 0.4.7

package/dist/chunk-AFRSS3C5.js

@@ -0,0 +1,494 @@
+import {
+  resolveInWorkspace,
+  resolveWorkspacePaths
+} from "./chunk-S7DI7HIF.js";
+
+// src/harness/phases/loader.ts
+import { existsSync as existsSync3 } from "fs";
+import { readdir } from "fs/promises";
+import { dirname as dirname2, join as join3 } from "path";
+
+// src/harness/loader.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { basename, dirname, extname, isAbsolute, join, resolve } from "path";
+function parseFrontmatter(raw) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!match) return { frontmatter: {}, body: raw };
+  const lines = match[1].split("\n");
+  const frontmatter = {};
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (!key) continue;
+    if (value === "" && i + 1 < lines.length) {
+      const nested = {};
+      while (i + 1 < lines.length) {
+        const next = lines[i + 1];
+        if (!next.startsWith("  ") || next.trim() === "") break;
+        const nIdx = next.indexOf(":");
+        if (nIdx === -1) break;
+        const nKey = next.slice(0, nIdx).trim();
+        const nValue = next.slice(nIdx + 1).trim();
+        nested[nKey] = nValue;
+        i++;
+      }
+      if (Object.keys(nested).length) {
+        frontmatter[key] = nested;
+      }
+      continue;
+    }
+    frontmatter[key] = parseValue(value);
+  }
+  return { frontmatter, body: raw.slice(match[0].length) };
+}
+function parseValue(value) {
+  const arrayMatch = value.match(/^\[(.*)\]$/);
+  if (arrayMatch) {
+    return arrayMatch[1].split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  if (value.toLowerCase() === "true") return true;
+  if (value.toLowerCase() === "false") return false;
+  if (/^\d+$/.test(value)) return Number(value);
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+async function loadMarkdown(filePath) {
+  const raw = await readFile(filePath, "utf8");
+  const { frontmatter, body } = parseFrontmatter(raw);
+  return { frontmatter, body, raw };
+}
+function isExplicitPath(input) {
+  return input.includes("/") || input.includes("\\") || Boolean(extname(input));
+}
+function inferResourceName(path, markerFile) {
+  const file = basename(path);
+  if (file.toLowerCase() === markerFile.toLowerCase()) {
+    return basename(dirname(path));
+  }
+  const extension = extname(file);
+  return extension ? file.slice(0, -extension.length) : file;
+}
+function resolveResourcePath(input, resourceType, markerFile, workspace) {
+  const ws = workspace ?? resolveWorkspacePaths();
+  if (isAbsolute(input)) {
+    return input;
+  }
+  if (!isExplicitPath(input)) {
+    return join(ws.rowanDir, resourceType, input, markerFile);
+  }
+  const workspacePath = resolveInWorkspace(input, ws);
+  if (existsSync(workspacePath)) {
+    return workspacePath;
+  }
+  return resolve(input);
+}
+
+// src/harness/config.ts
+import { existsSync as existsSync2 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2 } from "path";
+import { parse as parseYaml } from "yaml";
+import { registerModel } from "@rowan-agent/models";
+var DEFAULT_REASONING = false;
+var DEFAULT_INPUT = ["text"];
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+var DEFAULT_MAX_TOKENS = 16384;
+var DEFAULT_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+var DEFAULT_TIMEOUT_MS = 6e4;
+var ENV_VAR_PATTERN = /\$\{([^}]+)\}/g;
+function interpolateEnvVars(value) {
+  return value.replace(ENV_VAR_PATTERN, (match, varName) => {
+    const resolved = process.env[varName];
+    if (resolved === void 0 || resolved === "") {
+      throw new Error(
+        `Environment variable "${varName}" is not set but is referenced in config.yaml via "${match}".`
+      );
+    }
+    return resolved;
+  });
+}
+var CONFIG_CANDIDATES = ["config.yaml", "config.yml"];
+async function loadConfigFile(workspace) {
+  let configPath;
+  let configFilename;
+  for (const candidate of CONFIG_CANDIDATES) {
+    const p = join2(workspace.rowanDir, candidate);
+    if (existsSync2(p)) {
+      configPath = p;
+      configFilename = candidate;
+      break;
+    }
+  }
+  if (!configPath || !configFilename) {
+    return void 0;
+  }
+  const raw = await readFile2(configPath, "utf8");
+  let parsed;
+  try {
+    parsed = parseYaml(raw);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to parse .rowan/${configFilename}: ${message}`);
+  }
+  if (parsed === null || parsed === void 0) {
+    return void 0;
+  }
+  return validateConfigFile(parsed, configFilename);
+}
+function validateConfigFile(parsed, configFilename) {
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`.rowan/${configFilename} must be a YAML object at the top level.`);
+  }
+  const obj = parsed;
+  const providers = obj.providers;
+  if (!Array.isArray(providers)) {
+    throw new Error(`.rowan/${configFilename} must have a "providers" array.`);
+  }
+  const validatedProviders = providers.map((p, i) => {
+    if (typeof p !== "object" || p === null) {
+      throw new Error(`providers[${i}] must be an object.`);
+    }
+    const provider = p;
+    if (typeof provider.id !== "string" || !provider.id) {
+      throw new Error(`providers[${i}].id is required and must be a non-empty string.`);
+    }
+    if (typeof provider.baseUrl !== "string" || !provider.baseUrl) {
+      throw new Error(`providers[${i}].baseUrl is required and must be a non-empty string.`);
+    }
+    if (typeof provider.apiKey !== "string" || !provider.apiKey) {
+      throw new Error(`providers[${i}].apiKey is required and must be a non-empty string.`);
+    }
+    if (typeof provider.protocol !== "string" || !provider.protocol) {
+      throw new Error(`providers[${i}].protocol is required and must be a non-empty string.`);
+    }
+    if (!Array.isArray(provider.models) || provider.models.length === 0) {
+      throw new Error(`providers[${i}].models must be a non-empty array.`);
+    }
+    const interpolatedApiKey = interpolateEnvVars(provider.apiKey);
+    const validatedModels = provider.models.map((m, j) => {
+      if (typeof m !== "object" || m === null) {
+        throw new Error(`providers[${i}].models[${j}] must be an object.`);
+      }
+      const model = m;
+      if (typeof model.id !== "string" || !model.id) {
+        throw new Error(`providers[${i}].models[${j}].id is required and must be a non-empty string.`);
+      }
+      return model;
+    });
+    return {
+      id: provider.id,
+      baseUrl: provider.baseUrl,
+      apiKey: interpolatedApiKey,
+      protocol: provider.protocol,
+      ...typeof provider.name === "string" ? { name: provider.name } : {},
+      ...typeof provider.timeoutMs === "number" ? { timeoutMs: provider.timeoutMs } : {},
+      ...typeof provider.maxRetries === "number" ? { maxRetries: provider.maxRetries } : {},
+      ...typeof provider.retryDelayMs === "number" ? { retryDelayMs: provider.retryDelayMs } : {},
+      ...provider.headers && typeof provider.headers === "object" ? { headers: provider.headers } : {},
+      models: validatedModels
+    };
+  });
+  const result = { providers: validatedProviders };
+  if (obj.model && typeof obj.model === "object") {
+    const modelRef = obj.model;
+    if (typeof modelRef.provider !== "string" || typeof modelRef.id !== "string") {
+      throw new Error(`.rowan/${configFilename} "model" must have "provider" and "id" string fields.`);
+    }
+    result.model = { provider: modelRef.provider, id: modelRef.id };
+  }
+  if (obj.logLevel !== void 0) {
+    const valid = ["debug", "info", "warn", "error", "silent"];
+    if (typeof obj.logLevel !== "string" || !valid.includes(obj.logLevel)) {
+      throw new Error(`.rowan/${configFilename} "logLevel" must be one of: ${valid.join(", ")}.`);
+    }
+    result.logLevel = obj.logLevel;
+  }
+  return result;
+}
+function resolveDefaultModel(config) {
+  if (config.model) {
+    return { provider: config.model.provider, id: config.model.id };
+  }
+  for (const provider of config.providers) {
+    for (const model of provider.models) {
+      if (model.primary) {
+        return { provider: provider.id, id: model.id };
+      }
+    }
+  }
+  for (const provider of config.providers) {
+    if (provider.models.length > 0) {
+      return { provider: provider.id, id: provider.models[0].id };
+    }
+  }
+  return void 0;
+}
+function registerConfigModels(config) {
+  for (const provider of config.providers) {
+    for (const fileModel of provider.models) {
+      const model = {
+        id: fileModel.id,
+        name: fileModel.name ?? fileModel.id,
+        protocol: provider.protocol,
+        provider: provider.id,
+        baseUrl: provider.baseUrl,
+        reasoning: fileModel.reasoning ?? DEFAULT_REASONING,
+        input: fileModel.input ?? DEFAULT_INPUT,
+        cost: { ...DEFAULT_COST, ...fileModel.cost },
+        contextWindow: fileModel.contextWindow ?? DEFAULT_CONTEXT_WINDOW,
+        maxTokens: fileModel.maxTokens ?? DEFAULT_MAX_TOKENS,
+        apiKey: provider.apiKey,
+        timeoutMs: provider.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        ...provider.maxRetries !== void 0 ? { maxRetries: provider.maxRetries } : {},
+        ...provider.retryDelayMs !== void 0 ? { retryDelayMs: provider.retryDelayMs } : {},
+        ...provider.headers ? { headers: provider.headers } : {}
+      };
+      registerModel(model);
+    }
+  }
+}
+function parseModelRef(input) {
+  if (!input) return void 0;
+  const slashIndex = input.indexOf("/");
+  if (slashIndex === -1) {
+    return { provider: "*", id: input };
+  }
+  return {
+    provider: input.slice(0, slashIndex),
+    id: input.slice(slashIndex + 1)
+  };
+}
+
+// src/harness/context/resource-formatter.ts
+function escapeXml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function buildStructuredSection(tag, items) {
+  const lines = [];
+  for (const item of items) {
+    lines.push(`  <${tag}>`);
+    for (const [key, value] of Object.entries(item)) {
+      lines.push(`    <${key}>${escapeXml(value)}</${key}>`);
+    }
+    lines.push(`  </${tag}>`);
+  }
+  return lines.join("\n");
+}
+function buildSkillsDescription(skills) {
+  const visibleSkills = skills.filter((skill) => !skill.disableModelInvocation);
+  if (visibleSkills.length === 0) return "";
+  const lines = ["<available_skills>"];
+  for (const skill of visibleSkills) {
+    lines.push("  <skill>");
+    lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+    lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+    lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+    lines.push("  </skill>");
+  }
+  lines.push("</available_skills>");
+  return lines.join("\n");
+}
+function formatResourceOutput(resource) {
+  const parts = [`<${resource.type} name="${escapeXml(resource.name)}" location="${escapeXml(resource.location)}">`];
+  if (resource.baseDir) {
+    parts.push(`References are relative to ${resource.baseDir}.`);
+    parts.push("");
+  }
+  parts.push(resource.content);
+  parts.push(`</${resource.type}>`);
+  return parts.join("\n");
+}
+function detectResourceType(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (normalized.includes("/.rowan/skills/") && normalized.endsWith("/SKILL.md")) return "skill";
+  if (normalized.includes("/.rowan/phases/") && normalized.endsWith("/PHASE.md")) return "phase";
+  if (normalized.endsWith(".md")) return "markdown";
+  if (/\.(ts|js|tsx|jsx|py|rs|go|java|c|cpp|rb|sh|sql|yaml|yml|json|toml)$/.test(normalized)) return "code";
+  return "file";
+}
+function jsonToXml(value, depth) {
+  const indent = "  ".repeat(depth);
+  if (value === null || value === void 0) return "";
+  if (typeof value !== "object") return `${indent}${escapeXml(String(value))}`;
+  if (Array.isArray(value)) {
+    return value.map((item) => {
+      if (typeof item === "object" && item !== null) {
+        return `${indent}<item>
+${jsonToXml(item, depth + 1)}
+${indent}</item>`;
+      }
+      return `${indent}<item>${escapeXml(String(item))}</item>`;
+    }).join("\n");
+  }
+  return Object.entries(value).map(([key, val]) => {
+    const tag = escapeXml(key);
+    if (typeof val === "object" && val !== null) {
+      return `${indent}<${tag}>
+${jsonToXml(val, depth + 1)}
+${indent}</${tag}>`;
+    }
+    return `${indent}<${tag}>${escapeXml(String(val))}</${tag}>`;
+  }).join("\n");
+}
+function buildPhaseResultMessage(phases, toolUseId, instruction) {
+  const parts = [];
+  if (instruction) {
+    parts.push(`<instruction>${instruction}</instruction>`);
+  }
+  parts.push(`<phase_results>`);
+  for (const p of phases) {
+    parts.push(`  <phase name="${p.name}">`);
+    if (p.content) {
+      parts.push(`    <content>${p.content}</content>`);
+    }
+    if (p.output !== void 0) {
+      parts.push(`    <output>${jsonToXml(p.output, 2)}</output>`);
+    }
+    if (!p.content && p.output === void 0) {
+      parts.push(`    <content>Phase "${p.name}" completed with no output.</content>`);
+    }
+    parts.push(`  </phase>`);
+  }
+  parts.push(`</phase_results>`);
+  return [{
+    type: "tool_result",
+    toolUseId,
+    content: parts.join("\n"),
+    isError: false
+  }];
+}
+
+// src/harness/phases/loader.ts
+var PHASE_MARKER = "PHASE.md";
+var PHASE_DIR = "phases";
+async function loadPhase(input, workspace) {
+  const resolved = resolveResourcePath(input, PHASE_DIR, PHASE_MARKER, workspace);
+  const { frontmatter, body } = await loadMarkdown(resolved);
+  const baseDir = dirname2(resolved);
+  const phase = {
+    id: inferResourceName(resolved, PHASE_MARKER),
+    name: frontmatter.name ?? inferResourceName(resolved, PHASE_MARKER),
+    description: frontmatter.description ?? "",
+    tools: frontmatter.tools,
+    skills: frontmatter.skills,
+    target: frontmatter.target,
+    input: frontmatter.input,
+    isolated: frontmatter.isolated,
+    filePath: resolved,
+    baseDir,
+    content: body,
+    model: parseModelRef(frontmatter.model)
+  };
+  const codePath = await discoverPhaseCode(baseDir);
+  if (codePath) {
+    const code = await loadPhaseCode(codePath);
+    if (code.factory) {
+      phase.factory = code.factory;
+    } else if (code.run) {
+      phase.run = code.run;
+    }
+  }
+  return phase;
+}
+function readPhaseContent(phase) {
+  return formatResourceOutput({
+    type: "phase",
+    name: phase.name,
+    location: phase.filePath,
+    content: phase.content,
+    baseDir: phase.baseDir
+  });
+}
+async function loadPhases(workspace, paths) {
+  const phases = /* @__PURE__ */ new Map();
+  if (paths && paths.length > 0) {
+    for (const path of paths) {
+      const phase = await loadPhase(path, workspace);
+      phases.set(phase.id, phase);
+    }
+    return { phases, entryPhaseId: null };
+  }
+  const ws = workspace ?? (await import("./path-TJ2G5L4N.js")).resolveWorkspacePaths();
+  const phasesDir = join3(ws.rowanDir, PHASE_DIR);
+  if (!existsSync3(phasesDir)) {
+    return { phases, entryPhaseId: null };
+  }
+  const entries = await readdir(phasesDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const phaseFile = join3(phasesDir, entry.name, PHASE_MARKER);
+    if (!existsSync3(phaseFile)) continue;
+    try {
+      const phase = await loadPhase(entry.name, ws);
+      phases.set(phase.id, phase);
+    } catch (error) {
+      console.warn(`Failed to load phase "${entry.name}":`, error);
+    }
+  }
+  return { phases, entryPhaseId: null };
+}
+async function discoverPhaseCode(baseDir) {
+  const candidates = ["index.ts", "index.js"];
+  for (const candidate of candidates) {
+    const fullPath = join3(baseDir, candidate);
+    if (existsSync3(fullPath)) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+async function loadPhaseCode(codePath) {
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(import.meta.url, {
+    moduleCache: false
+  });
+  const mod = await jiti.import(codePath, { default: true });
+  const fn = typeof mod === "function" ? mod : mod?.default;
+  if (typeof fn === "function") {
+    return { factory: fn };
+  }
+  if (typeof mod?.run === "function") {
+    return { run: mod.run };
+  }
+  throw new Error(`Phase code at "${codePath}" must export a default function or a run() function.`);
+}
+async function reloadPhases(registry, workspace) {
+  for (const [id, phase] of registry.phases) {
+    if (!phase.filePath) {
+      continue;
+    }
+    try {
+      const fresh = await loadPhase(phase.filePath, workspace);
+      registry.phases.set(id, fresh);
+    } catch (error) {
+      console.warn(`Failed to reload phase "${id}":`, error);
+    }
+  }
+}
+
+export {
+  parseFrontmatter,
+  loadMarkdown,
+  inferResourceName,
+  resolveResourcePath,
+  interpolateEnvVars,
+  loadConfigFile,
+  resolveDefaultModel,
+  registerConfigModels,
+  parseModelRef,
+  buildStructuredSection,
+  buildSkillsDescription,
+  formatResourceOutput,
+  detectResourceType,
+  buildPhaseResultMessage,
+  loadPhase,
+  readPhaseContent,
+  loadPhases,
+  reloadPhases
+};

package/dist/chunk-S7DI7HIF.js

@@ -0,0 +1,145 @@
+// src/harness/env/path.ts
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { basename, dirname, isAbsolute, join, parse, relative, resolve, sep } from "path";
+var WORKSPACE_ENV = "ROWAN_WORKSPACE";
+var RUNTIME_ENV = "ROWAN_RUNTIME";
+var PACKAGED_ENV = "ROWAN_PACKAGED";
+var BINARY_WORKSPACE_DIR = ".rowan";
+function nonEmptyEnv(env, key) {
+  const value = env[key]?.trim();
+  return value ? value : void 0;
+}
+function isTruthyEnvValue(value) {
+  return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
+}
+function resolveUserPath(path, homeDir) {
+  if (path === "~") {
+    return homeDir;
+  }
+  if (path.startsWith("~/") || path.startsWith("~\\")) {
+    return join(homeDir, path.slice(2));
+  }
+  return resolve(path);
+}
+function isSourceWorkspaceRoot(path) {
+  const packagePath = join(path, "package.json");
+  if (!existsSync(packagePath)) {
+    return false;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync(packagePath, "utf8"));
+    return manifest.name === "rowan-agent" || Array.isArray(manifest.workspaces);
+  } catch {
+    return false;
+  }
+}
+function findSourceWorkspaceRoot(startDir = process.cwd()) {
+  let current = resolve(startDir);
+  const { root } = parse(current);
+  while (true) {
+    if (isSourceWorkspaceRoot(current)) {
+      return current;
+    }
+    if (current === root) {
+      return resolve(startDir);
+    }
+    current = dirname(current);
+  }
+}
+function detectRuntimeMode(input = {}) {
+  const env = input.env ?? process.env;
+  const explicitMode = nonEmptyEnv(env, RUNTIME_ENV)?.toLowerCase();
+  if (explicitMode === "source" || explicitMode === "binary") {
+    return explicitMode;
+  }
+  if (isTruthyEnvValue(nonEmptyEnv(env, PACKAGED_ENV))) {
+    return "binary";
+  }
+  const executable = basename(input.execPath ?? process.execPath).toLowerCase().replace(/\.exe$/, "");
+  return executable === "bun" ? "source" : "binary";
+}
+function defaultSourceStartDir(options) {
+  if (options.cwd) {
+    return options.cwd;
+  }
+  const entrypoint = options.entrypoint ?? process.argv[1];
+  if (entrypoint) {
+    const entrypointPath = resolve(process.cwd(), entrypoint);
+    if (existsSync(entrypointPath)) {
+      return dirname(entrypointPath);
+    }
+  }
+  return process.cwd();
+}
+function resolveWorkspaceRoot(options = {}) {
+  const env = options.env ?? process.env;
+  const homeDir = options.homeDir ?? homedir();
+  const override = nonEmptyEnv(env, WORKSPACE_ENV);
+  if (override) {
+    return resolveUserPath(override, homeDir);
+  }
+  const mode = options.mode ?? detectRuntimeMode(options);
+  if (mode === "binary") {
+    return homeDir;
+  }
+  return findSourceWorkspaceRoot(defaultSourceStartDir(options));
+}
+function resolveWorkspacePaths(options = {}) {
+  const mode = options.mode ?? detectRuntimeMode(options);
+  const cwd = resolveWorkspaceRoot({ ...options, mode });
+  return {
+    mode,
+    cwd,
+    rowanDir: join(cwd, BINARY_WORKSPACE_DIR)
+  };
+}
+function resolveInWorkspace(path, rootOrPaths) {
+  if (path === "~" || path.startsWith("~/") || path.startsWith("~\\")) {
+    return resolveUserPath(path, homedir());
+  }
+  if (isAbsolute(path)) {
+    return path;
+  }
+  const root = typeof rootOrPaths === "string" ? rootOrPaths : rootOrPaths.cwd;
+  return resolve(root, path);
+}
+function normalizeRelativePath(path) {
+  return path.split(sep).join("/");
+}
+function normalizeWorkspaceInputPath(path = ".") {
+  const trimmed = path.trim();
+  if (!trimmed || trimmed === "/" || trimmed === "\\") {
+    return ".";
+  }
+  return path;
+}
+function resolveWorkspacePath(context, path = ".") {
+  const root = resolve(context.root);
+  const inputPath = normalizeWorkspaceInputPath(path);
+  const absolutePath = resolve(root, inputPath);
+  const relativePath = relative(root, absolutePath);
+  if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+    throw new Error(`Path escapes workspace root: ${path}`);
+  }
+  return {
+    root,
+    inputPath,
+    absolutePath,
+    relativePath: normalizeRelativePath(relativePath || ".")
+  };
+}
+
+export {
+  WORKSPACE_ENV,
+  RUNTIME_ENV,
+  PACKAGED_ENV,
+  BINARY_WORKSPACE_DIR,
+  findSourceWorkspaceRoot,
+  detectRuntimeMode,
+  resolveWorkspaceRoot,
+  resolveWorkspacePaths,
+  resolveInWorkspace,
+  normalizeRelativePath,
+  resolveWorkspacePath
+};