@oisincoveney/pipeline 2.0.0 → 2.0.1

package/dist/install-commands/opencode.js

@@ -0,0 +1,422 @@
+import { DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST } from "../config/defaults.js";
+import { resolvePackageAssetPath } from "../package-assets.js";
+import "../config.js";
+import { compileWorkflowPlan } from "../workflow-planner.js";
+import { renderOpenCodeGatewayConfig } from "../mcp/gateway.js";
+import { AGENTS_MD_END, AGENTS_MD_START, COMMAND_HOSTS, GENERATED_MARKER, GENERATED_TS_MARKER, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, invocationForHost } from "./shared.js";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import matter from "gray-matter";
+//#region src/install-commands/opencode.ts
+const OPENCODE_ORCHESTRATOR_AGENT_ID = "MoKa Orchestrator";
+const MOKA_PROFILE_PREFIX = "moka-";
+function header(host) {
+	return [
+		GENERATED_MARKER,
+		`${OWNER_MARKER_PREFIX}host=${host} -->`,
+		""
+	].join("\n");
+}
+function markdown(data, body) {
+	return `${matter.stringify(body.trimEnd(), data).trimEnd()}\n`;
+}
+function profileEntries(config) {
+	return Object.entries(config.profiles).sort(([a], [b]) => a.localeCompare(b));
+}
+function entrypointEntries(config) {
+	const entries = Object.entries(config.entrypoints);
+	return entries.length > 0 ? entries : [["execute", {
+		description: "Run the configured pipeline workflow",
+		workflow: config.default_workflow
+	}]];
+}
+function entrypointDescription(id, entrypoint) {
+	return entrypoint.description ?? `Run the ${id} workflow`;
+}
+function entrypointCommandDefinitions(_host, config, makeDefinition) {
+	return entrypointEntries(config).map(([id, entrypoint]) => makeDefinition(id, entrypoint));
+}
+function nativeProfileEntries(host, config) {
+	return profileEntries(config).filter(([id, profile]) => id !== config.orchestrator?.profile && canRunNatively(host, profile));
+}
+function orchestratorProfile(config) {
+	if (!config.orchestrator) return;
+	const profile = config.profiles[config.orchestrator.profile];
+	if (!profile) throw new Error(`Orchestrator profile '${config.orchestrator.profile}' is not declared.`);
+	return { ...profile };
+}
+function resolvedHostModel(config, host, profile) {
+	const runner = config.runners[profile.runner];
+	const hostRunner = config.runners[host];
+	if (profile.host_models?.[host]) return profile.host_models[host];
+	if (runner?.host_models?.[host]) return runner.host_models[host];
+	if (profile.runner === host) return profile.model ?? runner?.model;
+	return hostRunner?.model;
+}
+function canRunNatively(host, profile) {
+	if (profile.runner === host) return true;
+	return host === "opencode" && isModelRunner(profile.runner);
+}
+function isModelRunner(runnerId) {
+	return COMMAND_HOSTS.some((host) => host === runnerId);
+}
+function agentDispatchRoutes(host, config, workflowId = config.default_workflow) {
+	return compileWorkflowPlan(config, workflowId).topologicalOrder.flatMap((node) => {
+		if (!(node.kind === "agent" && node.profile)) return [];
+		const profile = config.profiles[node.profile];
+		if (!profile) return [];
+		return [dispatchRouteForAgent(host, config, {
+			needs: node.needs,
+			nodeId: node.id,
+			profile,
+			profileId: node.profile
+		})];
+	});
+}
+function dispatchRouteForAgent(host, config, route) {
+	const runnerId = route.profile.runner;
+	if (runnerId === host) {
+		const model = resolvedHostModel(config, host, route.profile);
+		return {
+			...route,
+			kind: "native-named-agent",
+			...model ? { model } : {},
+			nativeAgentId: nativeAgentIdForHost(host, route.profileId),
+			runnerId
+		};
+	}
+	if (host === "opencode" && isModelRunner(runnerId)) {
+		const model = resolvedHostModel(config, host, route.profile);
+		return {
+			...route,
+			kind: "native-model-agent",
+			...model ? { model } : {},
+			nativeAgentId: nativeAgentIdForHost(host, route.profileId),
+			runnerId
+		};
+	}
+	return {
+		...route,
+		kind: "cli",
+		runnerId
+	};
+}
+function nativeAgentIdForHost(host, profileId) {
+	return host === "opencode" ? opencodeAgentName(profileId) : profileId;
+}
+function opencodeAgentName(profileId) {
+	if (!profileId.startsWith(MOKA_PROFILE_PREFIX)) return profileId;
+	return `MoKa ${profileId.slice(5).split("-").map(opencodeAgentNamePart).join(" ")}`;
+}
+function opencodeAgentNamePart(part) {
+	if (part === "opencode") return "OpenCode";
+	return `${part.charAt(0).toUpperCase()}${part.slice(1)}`;
+}
+function grants(actor) {
+	return [
+		`model: ${actor.model ?? "default"}`,
+		`tools: ${(actor.tools ?? []).join(", ") || "none"}`,
+		`rules: ${(actor.rules ?? []).join(", ") || "none"}`,
+		`skills: ${(actor.skills ?? []).join(", ") || "none"}`,
+		`mcp_servers: ${(actor.mcp_servers ?? []).join(", ") || "none"}`,
+		`filesystem: ${actor.filesystem?.mode ?? "default"}`,
+		`network: ${actor.network?.mode ?? "default"}`,
+		..."output" in actor ? [`output: ${actor.output?.format ?? "text"}`] : []
+	].join("\n");
+}
+function orchestratorBlock(config) {
+	const profile = orchestratorProfile(config);
+	if (!profile) return "Configured orchestrator: none";
+	return [
+		"Configured orchestrator:",
+		grants(profile),
+		`hooks: ${Object.keys(config.hooks.functions).join(", ") || "none"}`,
+		"",
+		instructionsPointer(profile)
+	].join("\n");
+}
+function dispatchBlock(host, config, workflowId = config.default_workflow) {
+	const routes = agentDispatchRoutes(host, config, workflowId);
+	if (routes.length === 0) return;
+	const plan = compileWorkflowPlan(config, workflowId);
+	const nativeRoutes = routes.filter((route) => route.kind !== "cli");
+	const cliRoutes = routes.filter((route) => route.kind === "cli");
+	return [
+		`Run workflow \`${plan.workflowId}\` for the user task.`,
+		"",
+		nativeDispatchBlock(host, nativeRoutes),
+		cliDispatchBlock(host, cliRoutes),
+		nodePromptContract(plan.workflowId, routes),
+		"Only package-configured gates are blocking. Do not invent RED, GREEN, full-suite, typecheck, or unrelated-drift gates.",
+		"If a node returns targeted evidence and has no configured blocking gate, advance to the next node.",
+		"Do not bypass configured runner subprocesses or package-configured gates when executing nodes.",
+		"Use the listed Task tool routes for native nodes, and run nodes with satisfied dependencies in parallel whenever the host supports concurrent subagent work.",
+		hostSpecificDispatchGuard(host, nativeRoutes, cliRoutes)
+	].filter((line) => Boolean(line)).join("\n");
+}
+function entrypointDispatchBlock(host, config, id, entrypoint) {
+	if ("workflow" in entrypoint) return dispatchBlock(host, config, entrypoint.workflow);
+	return [
+		`Generate a schedule for entrypoint \`${id}\` and the user task.`,
+		`The schedule policy is \`${entrypoint.schedule}\`.`,
+		id === "quick" ? "Run `moka submit --quick <task description>` to submit the graph as an Argo Workflow." : `Run \`moka submit <task description>\` to submit the \`${id}\` graph as an Argo Workflow.`,
+		"The pipeline runtime executes as Argo DAG tasks using the package-owned runner image.",
+		"Configure the target in `~/.config/moka/config.yaml`; use `--kubeconfig <path>` and `--namespace <namespace>` only for explicit command overrides.",
+		"Use `moka submit --schedule <schedule.yaml> <task description>` only when rerunning an existing schedule artifact."
+	].join("\n");
+}
+function scheduledEntrypointK8sNote(entrypoint) {
+	if ("workflow" in entrypoint) return;
+	return "Submit Momokaya work as Argo Workflows through `moka submit` and `moka submit --quick`.";
+}
+function orchestratorEntrypointDispatchBlock(host, config) {
+	const scheduledEntrypoints = entrypointEntries(config).filter(([, entrypoint]) => !("workflow" in entrypoint));
+	if (scheduledEntrypoints.length === 0) return dispatchBlock(host, config);
+	return scheduledEntrypoints.map(([id, entrypoint]) => entrypointDispatchBlock(host, config, id, entrypoint)).filter((block) => Boolean(block)).join("\n\n");
+}
+function nativeDispatchBlock(host, routes) {
+	if (routes.length === 0) return;
+	return [
+		`${hostDisplayName(host)} native routes:`,
+		...routes.map(nativeDispatchLine),
+		""
+	].join("\n");
+}
+function nativeDispatchLine(route) {
+	const needs = needsSummary(route.needs);
+	const model = route.model ? ` model=${route.model}` : "";
+	return `- ${route.nodeId}: Task tool subagent_type=${route.nativeAgentId}${model} runner=${route.runnerId} needs=${needs}`;
+}
+function cliDispatchBlock(host, routes) {
+	if (routes.length === 0) return;
+	return [
+		`These nodes are not ${hostDisplayName(host)} native routes.`,
+		"CLI routes:",
+		...routes.map(cliDispatchLine),
+		""
+	].join("\n");
+}
+function cliDispatchLine(route) {
+	return `- ${route.nodeId}: ${route.runnerId} CLI profile=${route.profileId} command=\`${runnerCliCommand(route)}\` needs=${needsSummary(route.needs)}`;
+}
+function runnerCliCommand(route) {
+	if (route.runnerId === "opencode") return `opencode run --agent "${opencodeAgentName(route.profileId)}" --format json --dir <repo-root> <node prompt>`;
+	throw new Error(`runner '${route.runnerId}' cannot be represented as a supported native or CLI route`);
+}
+function nodePromptContract(workflowId, routes) {
+	return [
+		routes.some((route) => route.kind === "cli") ? "For each CLI node prompt include:" : "For each native node prompt include:",
+		"- user task",
+		`- workflow id: ${workflowId}`,
+		"- node id",
+		"- profile id",
+		"- runner id",
+		"- profile instructions reference",
+		"- profile grants",
+		"- dependency outputs",
+		""
+	].join("\n");
+}
+function hostSpecificDispatchGuard(host, nativeRoutes, cliRoutes) {
+	if (cliRoutes.length > 0 && nativeRoutes.length > 0) return `Do not claim CLI routes are ${hostDisplayName(host)} native routes.`;
+	if (cliRoutes.length > 0 && nativeRoutes.length === 0) return `Do not claim these nodes are ${hostDisplayName(host)} subagents.`;
+}
+function hostDisplayName(host) {
+	return { opencode: "OpenCode" }[host];
+}
+function needsSummary(needs) {
+	return needs.length > 0 ? needs.join(",") : "none";
+}
+function compactLines(lines) {
+	return lines.filter((line) => line !== void 0);
+}
+const OPENCODE_PERMISSION_TOOLS = [
+	"bash",
+	"edit",
+	"glob",
+	"grep",
+	"list",
+	"read",
+	"write"
+];
+function opencodePermission(actor, options = {}) {
+	const allowed = new Set(actor.tools ?? []);
+	return {
+		...opencodeToolPermissions(allowed),
+		external_directory: "deny",
+		lsp: "allow",
+		skill: opencodeSkillPermission(actor.skills ?? []),
+		task: opencodeTaskPermission(allowed, options.allowedTaskAgents ?? [])
+	};
+}
+function opencodeToolPermissions(allowed) {
+	return Object.fromEntries(OPENCODE_PERMISSION_TOOLS.map((tool) => [tool, allowed.has(tool) ? "allow" : "deny"]));
+}
+function opencodeSkillPermission(skills) {
+	return namedOpencodePermissionMap(skills);
+}
+function opencodeTaskPermission(allowed, allowedTaskAgents) {
+	return allowedTaskAgents.length > 0 ? namedOpencodePermissionMap(allowedTaskAgents) : toolPermission(allowed, "task");
+}
+function namedOpencodePermissionMap(names) {
+	return names.length > 0 ? {
+		"*": "deny",
+		...Object.fromEntries(names.map((name) => [name, "allow"]))
+	} : "deny";
+}
+function toolPermission(allowed, tool) {
+	return allowed.has(tool) ? "allow" : "deny";
+}
+function renderOpenCodeProjectConfig(config) {
+	return formatOpenCodeProjectJson({
+		...config.mcp_gateway ? JSON.parse(renderOpenCodeGatewayConfig(config)) : { $schema: "https://opencode.ai/config.json" },
+		lsp: true,
+		...opencodePluginConfig()
+	});
+}
+function opencodePluginConfig() {
+	const plugins = DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST.ecosystem_code.flatMap((item) => npmPluginPackage(item)).sort((a, b) => a.localeCompare(b));
+	return plugins.length > 0 ? { plugin: plugins } : {};
+}
+function npmPluginPackage(item) {
+	if (item.plugin?.kind === "npm") return [item.plugin.package];
+	return [];
+}
+function formatOpenCodeProjectJson(value) {
+	return `${JSON.stringify(value, null, 2).replace(SINGLE_OPENCODE_PLUGIN_ARRAY_RE, "\n  \"plugin\": [$1]")}\n`;
+}
+function localPluginDefinitions() {
+	return DEFAULT_OPENCODE_ECOSYSTEM_MANIFEST.ecosystem_code.flatMap((item) => {
+		if (item.plugin?.kind !== "local") return [];
+		const plugin = readFileSync(resolvePackageAssetPath(item.plugin.source_path), "utf8").trimEnd();
+		return [{
+			content: [
+				GENERATED_TS_MARKER,
+				`${OWNER_TS_MARKER_PREFIX}host=opencode`,
+				"",
+				plugin,
+				""
+			].join("\n"),
+			host: "opencode",
+			invocation: invocationForHost("opencode"),
+			path: item.plugin.target_path
+		}];
+	});
+}
+function opencodeDefinitions(config, cwd) {
+	const orchestrator = orchestratorProfile(config);
+	return [
+		...entrypointCommandDefinitions("opencode", config, (id, entrypoint) => ({
+			content: markdown({
+				...orchestrator ? { agent: OPENCODE_ORCHESTRATOR_AGENT_ID } : {},
+				description: entrypointDescription(id, entrypoint)
+			}, compactLines([
+				header("opencode").trimEnd(),
+				"",
+				`Invoke this command with \`${invocationForHost("opencode", id)}\`.`,
+				"",
+				orchestratorBlock(config),
+				"",
+				scheduledEntrypointK8sNote(entrypoint),
+				scheduledEntrypointK8sNote(entrypoint) ? "" : void 0,
+				entrypointDispatchBlock("opencode", config, id, entrypoint)
+			]).join("\n")),
+			host: "opencode",
+			invocation: invocationForHost("opencode", id),
+			path: `.opencode/commands/${commandIdForHost("opencode", id)}.md`
+		})),
+		{
+			content: renderOpenCodeProjectConfig(config),
+			host: "opencode",
+			invocation: invocationForHost("opencode"),
+			path: ".opencode/opencode.json"
+		},
+		...orchestrator ? [{
+			content: markdown({
+				description: "Orchestrate the configured pipeline and enforce gates.",
+				mode: "primary",
+				name: OPENCODE_ORCHESTRATOR_AGENT_ID,
+				permission: opencodePermission(orchestrator, { allowedTaskAgents: agentDispatchRoutes("opencode", config).filter((route) => route.kind !== "cli").map((route) => route.nativeAgentId).filter((id) => Boolean(id)) })
+			}, compactLines([
+				header("opencode").trimEnd(),
+				"",
+				orchestratorBlock(config),
+				"",
+				orchestratorEntrypointDispatchBlock("opencode", config)
+			]).join("\n")),
+			host: "opencode",
+			invocation: invocationForHost("opencode"),
+			path: `.opencode/agents/${OPENCODE_ORCHESTRATOR_AGENT_ID}.md`
+		}] : [],
+		...nativeProfileEntries("opencode", config).map(([id, profile]) => ({
+			content: markdown({
+				name: nativeAgentIdForHost("opencode", id),
+				description: profile.description ?? id,
+				hidden: false,
+				mode: "all",
+				...opencodeModelProjection(config, profile),
+				permission: opencodePermission(profile)
+			}, [
+				header("opencode").trimEnd(),
+				"",
+				profile.description ?? id,
+				"",
+				"Configured grants:",
+				grants(profile),
+				"",
+				instructionsPointer(profile)
+			].join("\n")),
+			host: "opencode",
+			invocation: invocationForHost("opencode"),
+			path: `.opencode/agents/${nativeAgentIdForHost("opencode", id)}.md`
+		})),
+		...localPluginDefinitions(),
+		projectAgentsMdDefinition(cwd, "opencode")
+	];
+}
+function projectAgentsMdDefinition(cwd, host) {
+	const repoName = basename(cwd);
+	return {
+		block: {
+			end: AGENTS_MD_END,
+			start: AGENTS_MD_START
+		},
+		content: [
+			AGENTS_MD_START,
+			GENERATED_MARKER,
+			`${OWNER_MARKER_PREFIX}host=opencode -->`,
+			"",
+			"## Pipeline Guidance",
+			"",
+			"This repository uses package-owned `@oisincoveney/pipeline` config.",
+			"",
+			"- Use `/moka-quick`, `/moka-execute`, or `/moka-inspect` for OpenCode slash-command entrypoints when available.",
+			"- Load and follow the relevant skill from `.agents/skills` before doing specialized work.",
+			"- Prefer the package-defined pipeline profiles and generated command surfaces over ad hoc subagent prompts.",
+			"",
+			"## Pipeline Memory",
+			"",
+			`Use Qdrant collection \`${repoName}\` for this repository.`,
+			"",
+			`- Call \`qdrant-find\` before research with \`collection_name: ${repoName}\` unless the user explicitly disables memory.`,
+			`- Call \`qdrant-store\` during LEARN with \`collection_name: ${repoName}\` for durable lessons worth reusing.`,
+			"- Include metadata with at least `repo`, `phase`, `workflow` or `entrypoint`, `task`, and `outcome` when storing lessons.",
+			"",
+			AGENTS_MD_END,
+			""
+		].join("\n"),
+		host,
+		invocation: invocationForHost(host),
+		path: "AGENTS.md"
+	};
+}
+function opencodeModelProjection(config, profile) {
+	const model = resolvedHostModel(config, "opencode", profile);
+	return model ? { model } : {};
+}
+function instructionsPointer(actor) {
+	if (actor.instructions.path) return `Instructions: ${actor.instructions.path}`;
+	return `Instructions:\n${actor.instructions.inline ?? ""}`;
+}
+//#endregion
+export { opencodeDefinitions };

package/dist/install-commands/shared.js

@@ -0,0 +1,23 @@
+//#region src/install-commands/shared.ts
+const GENERATED_MARKER = "<!-- Generated by @oisincoveney/pipeline. -->";
+const GENERATED_TS_MARKER = "// Generated by @oisincoveney/pipeline.";
+const GENERATED_YAML_MARKER = "# Generated by @oisincoveney/pipeline.";
+const OWNER_MARKER_PREFIX = "<!-- @oisincoveney/pipeline:";
+const OWNER_TS_MARKER_PREFIX = "// @oisincoveney/pipeline:";
+const OWNER_YAML_MARKER_PREFIX = "# @oisincoveney/pipeline:";
+const AGENTS_MD_START = "<!-- @oisincoveney/pipeline:agents:start -->";
+const AGENTS_MD_END = "<!-- @oisincoveney/pipeline:agents:end -->";
+const SINGLE_OPENCODE_PLUGIN_ARRAY_RE = /\n {2}"plugin": \[\n {4}("[^"]+")\n {2}\]/;
+const OPENCODE_PROJECT_CONFIG_PATH = ".opencode/opencode.json";
+const OPENCODE_COMMAND_PREFIX = "moka-";
+const ENTRYPOINT_PATH_PATTERNS = { opencode: [/^\.opencode\/commands\/(?:moka-)?([^/]+)\.md$/] };
+const COMMAND_HOSTS = ["opencode"];
+function invocationForHost(host, entrypointId = "execute") {
+	return `${{ opencode: "/" }[host]}${commandIdForHost(host, entrypointId)} <task description>`;
+}
+function commandIdForHost(host, entrypointId) {
+	if (host === "opencode") return `${OPENCODE_COMMAND_PREFIX}${entrypointId}`;
+	return entrypointId;
+}
+//#endregion
+export { AGENTS_MD_END, AGENTS_MD_START, COMMAND_HOSTS, ENTRYPOINT_PATH_PATTERNS, GENERATED_MARKER, GENERATED_TS_MARKER, GENERATED_YAML_MARKER, OPENCODE_PROJECT_CONFIG_PATH, OWNER_MARKER_PREFIX, OWNER_TS_MARKER_PREFIX, OWNER_YAML_MARKER_PREFIX, SINGLE_OPENCODE_PLUGIN_ARRAY_RE, commandIdForHost, invocationForHost };