@kodrunhq/opencode-autopilot 1.12.1 → 1.14.0

package/src/orchestrator/wave-assigner.ts

@@ -0,0 +1,117 @@
+/**
+ * Automatic wave assignment from task dependencies using Kahn's algorithm.
+ * Tasks declare depends_on arrays, this module computes optimal wave numbers.
+ * Reuses the cycle detection concept from src/skills/dependency-resolver.ts.
+ */
+
+export interface TaskNode {
+	readonly id: number;
+	readonly depends_on: readonly number[];
+}
+
+export interface WaveAssignment {
+	readonly assignments: ReadonlyMap<number, number>; // taskId -> wave number
+	readonly cycles: readonly number[]; // task IDs participating in cycles
+}
+
+/** Hard cap on task count to prevent DoS via crafted dependency chains. */
+const MAX_TASKS = 500;
+
+/**
+ * Assign wave numbers to tasks based on their depends_on relationships.
+ * Uses Kahn's algorithm (BFS-based topological sort):
+ *   1. Build in-degree map from depends_on
+ *   2. All tasks with in-degree 0 -> Wave 1
+ *   3. Remove Wave 1, decrement in-degrees of dependents
+ *   4. Repeat for Wave 2, 3, etc.
+ *   5. Any remaining tasks are in cycles
+ *
+ * Tasks with empty depends_on arrays get wave 1 (backward compatible).
+ * Dependencies referencing non-existent task IDs are silently ignored.
+ */
+export function assignWaves(tasks: readonly TaskNode[]): WaveAssignment {
+	if (tasks.length === 0) {
+		return Object.freeze({
+			assignments: Object.freeze(new Map<number, number>()),
+			cycles: Object.freeze([] as number[]),
+		});
+	}
+
+	if (tasks.length > MAX_TASKS) {
+		return Object.freeze({
+			assignments: Object.freeze(new Map<number, number>()),
+			cycles: Object.freeze(tasks.map((t) => t.id)),
+		});
+	}
+
+	// Build set of valid task IDs
+	const validIds = new Set(tasks.map((t) => t.id));
+
+	// Build adjacency list: for each task, which tasks depend on it
+	// (reverse of depends_on — "dependents" map)
+	const dependents = new Map<number, number[]>();
+	for (const id of validIds) {
+		dependents.set(id, []);
+	}
+
+	// Build in-degree map: count of valid dependencies per task
+	// Deduplicate depends_on and skip self-dependencies
+	const inDegree = new Map<number, number>();
+	for (const task of tasks) {
+		const uniqueDeps = [...new Set(task.depends_on)];
+		let degree = 0;
+		for (const dep of uniqueDeps) {
+			if (dep === task.id) continue; // Skip self-dependency
+			if (validIds.has(dep)) {
+				degree++;
+				const list = dependents.get(dep);
+				if (list) {
+					list.push(task.id);
+				}
+			}
+		}
+		inDegree.set(task.id, degree);
+	}
+
+	// BFS: process waves
+	const assignments = new Map<number, number>();
+	let currentQueue: number[] = [];
+
+	// Initialize with all tasks that have in-degree 0 (wave 1)
+	for (const task of tasks) {
+		if ((inDegree.get(task.id) ?? 0) === 0) {
+			currentQueue.push(task.id);
+		}
+	}
+
+	let wave = 1;
+	while (currentQueue.length > 0) {
+		const nextQueue: number[] = [];
+		for (const taskId of currentQueue) {
+			assignments.set(taskId, wave);
+			const deps = dependents.get(taskId) ?? [];
+			for (const dependent of deps) {
+				const newDegree = (inDegree.get(dependent) ?? 1) - 1;
+				inDegree.set(dependent, newDegree);
+				if (newDegree === 0) {
+					nextQueue.push(dependent);
+				}
+			}
+		}
+		currentQueue = nextQueue;
+		wave++;
+	}
+
+	// Any tasks not assigned a wave are in cycles
+	const cycleIds: number[] = [];
+	for (const task of tasks) {
+		if (!assignments.has(task.id)) {
+			cycleIds.push(task.id);
+		}
+	}
+
+	return Object.freeze({
+		assignments: Object.freeze(new Map(assignments)),
+		cycles: Object.freeze(cycleIds),
+	});
+}

package/src/review/selection.ts

@@ -1,10 +1,8 @@
 /**
- * Two-pass deterministic agent selection for the review pipeline.
+ * Deterministic agent selection for the review pipeline.
  *
- * Pass 1: Stack gate -- agents with empty relevantStacks always pass;
- *         agents with non-empty relevantStacks require at least one match.
- * Pass 2: Diff relevance scoring -- currently used for future ordering,
- *         all stack-passing agents run regardless of score.
+ * Stack gate: agents with empty relevantStacks always pass;
+ * agents with non-empty relevantStacks require at least one match.
  */
 
 /** Minimal agent shape needed for selection (compatible with ReviewAgent from agents/). */
@@ -38,7 +36,7 @@ export interface SelectionResult {
  */
 export function selectAgents(
 	detectedStacks: readonly string[],
-	diffAnalysis: DiffAnalysisInput,
+	_diffAnalysis: DiffAnalysisInput,
 	agents: readonly SelectableAgent[],
 ): SelectionResult {
 	const stackSet = new Set(detectedStacks);
@@ -65,34 +63,8 @@ export function selectAgents(
 		}
 	}
 
-	// Pass 2: Compute relevance scores (stored for future ordering, no filtering)
-	// Scores are intentionally not used for filtering yet
-	for (const agent of selected) {
-		computeDiffRelevance(agent, diffAnalysis);
-	}
-
 	return Object.freeze({
 		selected: Object.freeze(selected),
 		excluded: Object.freeze(excluded),
 	});
 }
-
-/**
- * Compute diff-based relevance score for an agent.
- * Base score of 1.0 with bonuses for specific agent-analysis matches.
- * Used for future prioritization/ordering, not for filtering.
- */
-export function computeDiffRelevance(agent: SelectableAgent, analysis: DiffAnalysisInput): number {
-	let score = 1.0;
-
-	if (agent.name === "security-auditor") {
-		if (analysis.hasAuth) score += 0.5;
-		if (analysis.hasConfig) score += 0.3;
-	}
-
-	if (agent.name === "test-interrogator") {
-		if (!analysis.hasTests) score += 0.5;
-	}
-
-	return score;
-}

package/src/skills/adaptive-injector.ts

@@ -18,6 +18,24 @@ const DEFAULT_TOKEN_BUDGET = 8000;
 /** Rough estimate: 1 token ~ 4 chars */
 const CHARS_PER_TOKEN = 4;
 
+/**
+ * Maps pipeline phases to the skill names relevant for that phase.
+ * Skills not in the list for the current phase are excluded from injection,
+ * preventing the full 13-19KB per-skill content from bloating every dispatch.
+ */
+export const PHASE_SKILL_MAP: Readonly<Record<string, readonly string[]>> = Object.freeze({
+	RECON: ["plan-writing"],
+	CHALLENGE: ["plan-writing"],
+	ARCHITECT: ["plan-writing"],
+	PLAN: ["plan-writing", "plan-executing"],
+	BUILD: ["coding-standards", "tdd-workflow"],
+	SHIP: ["plan-executing"],
+	RETROSPECTIVE: [],
+	EXPLORE: [],
+});
+
+export type SkillMode = "summary" | "full";
+
 /**
  * Manifest files that indicate project stack.
  * Checks project root for these files to detect the stack.
@@ -121,14 +139,40 @@ export function filterSkillsByStack(
 	return filtered;
 }
 
+/**
+ * Build a compact summary for a single skill: frontmatter name + description
+ * (max 200 chars). Used in summary mode to avoid injecting full skill content.
+ */
+export function buildSkillSummary(skill: LoadedSkill): string {
+	const { name, description } = skill.frontmatter;
+	const safeName = sanitizeTemplateContent(name);
+	const safeDesc = sanitizeTemplateContent((description ?? "").slice(0, 200));
+	return `[Skill: ${safeName}]\n${safeDesc}`;
+}
+
+/**
+ * In full mode, truncate skill content at the first `## ` heading boundary
+ * that exceeds the per-skill character budget. Preserves structure instead
+ * of collapsing all newlines.
+ */
+function truncateAtSectionBoundary(content: string, maxChars: number): string {
+	if (content.length <= maxChars) return content;
+	const cutPoint = content.lastIndexOf("\n## ", maxChars);
+	if (cutPoint > 0) return content.slice(0, cutPoint);
+	return content.slice(0, maxChars);
+}
+
 /**
  * Build multi-skill context string with dependency ordering and token budget.
  * Skills are ordered by dependency (prerequisites first), then concatenated
  * until the token budget is exhausted.
+ *
+ * @param mode - "summary" emits only name + description (compact); "full" preserves structure
  */
 export function buildMultiSkillContext(
 	skills: ReadonlyMap<string, LoadedSkill>,
 	tokenBudget: number = DEFAULT_TOKEN_BUDGET,
+	mode: SkillMode = "summary",
 ): string {
 	if (skills.size === 0) return "";
 
@@ -151,17 +195,64 @@ export function buildMultiSkillContext(
 		const skill = skills.get(name);
 		if (!skill) continue;
 
-		const collapsed = skill.content.replace(/[\r\n]+/g, " ");
-		const header = `[Skill: ${name}]\n`;
+		let section: string;
+		if (mode === "summary") {
+			section = sanitizeTemplateContent(buildSkillSummary(skill));
+		} else {
+			// Full mode: preserve structure, truncate at section boundaries
+			const header = `[Skill: ${name}]\n`;
+			const perSkillBudget = Math.max(charBudget - totalChars - header.length, 0);
+			const truncated = truncateAtSectionBoundary(skill.content, perSkillBudget);
+			const sanitized = sanitizeTemplateContent(truncated);
+			section = `${header}${sanitized}`;
+		}
+
 		const separator = sections.length > 0 ? 2 : 0; // "\n\n"
-		const sectionCost = collapsed.length + header.length + separator;
+		const sectionCost = section.length + separator;
 		if (totalChars + sectionCost > charBudget) break;
 
-		const sanitized = sanitizeTemplateContent(collapsed);
-		sections.push(`${header}${sanitized}`);
+		sections.push(section);
 		totalChars += sectionCost;
 	}
 
 	if (sections.length === 0) return "";
 	return `\n\nSkills context (follow these conventions and methodologies):\n${sections.join("\n\n")}`;
 }
+
+/**
+ * Build adaptive skill context with optional phase filtering.
+ *
+ * When `phase` is provided, only skills listed in PHASE_SKILL_MAP for that
+ * phase are included (pipeline dispatch path). When omitted, all stack-filtered
+ * skills are included (direct chat injection path).
+ */
+export function buildAdaptiveSkillContext(
+	skills: ReadonlyMap<string, LoadedSkill>,
+	options?: {
+		readonly phase?: string;
+		readonly budget?: number;
+		readonly mode?: SkillMode;
+	},
+): string {
+	const phase = options?.phase;
+	const budget = options?.budget ?? DEFAULT_TOKEN_BUDGET;
+	const mode = options?.mode ?? "summary";
+
+	if (phase !== undefined) {
+		const allowedNames = PHASE_SKILL_MAP[phase] ?? [];
+		if (allowedNames.length === 0) return "";
+
+		const allowedSet = new Set(allowedNames);
+		const filtered = new Map<string, LoadedSkill>();
+		for (const [name, skill] of skills) {
+			if (allowedSet.has(name)) {
+				filtered.set(name, skill);
+			}
+		}
+
+		return buildMultiSkillContext(filtered, budget, mode);
+	}
+
+	// No phase -- include all provided skills (caller already stack-filtered)
+	return buildMultiSkillContext(skills, budget, mode);
+}

package/src/skills/loader.ts

@@ -84,5 +84,8 @@ export async function loadAllSkills(skillsDir: string): Promise<ReadonlyMap<stri
 		if (!isEnoentError(error)) throw error;
 	}
 
-	return skills;
+	// Sort alphabetically by name for deterministic ordering regardless of
+	// filesystem readdir order (which varies across OS and FS types).
+	const sorted = new Map([...skills.entries()].sort(([a], [b]) => a.localeCompare(b)));
+	return Object.freeze(sorted);
 }

package/src/tools/hashline-edit.ts

@@ -0,0 +1,317 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+import { tool } from "@opencode-ai/plugin";
+
+/**
+ * CID alphabet from omo — 16 uppercase characters used for 2-char line hashes.
+ */
+export const CID_ALPHABET = "ZPMQVRWSNKTXJBYH";
+
+const CID_SET = new Set(CID_ALPHABET);
+
+/**
+ * FNV-1a 32-bit hash.
+ */
+function fnv1a(str: string): number {
+	let hash = 0x811c9dc5; // FNV offset basis
+	for (let i = 0; i < str.length; i++) {
+		hash ^= str.charCodeAt(i);
+		hash = Math.imul(hash, 0x01000193); // FNV prime
+	}
+	return hash >>> 0;
+}
+
+/**
+ * Compute a 2-character line hash using FNV-1a and CID alphabet.
+ */
+export function computeLineHash(content: string): string {
+	const h = fnv1a(content);
+	return CID_ALPHABET[h & 0xf] + CID_ALPHABET[(h >> 4) & 0xf];
+}
+
+/**
+ * Parse a "LINE#HASH" anchor string into its components.
+ */
+export function parseAnchor(
+	anchor: string,
+): { readonly line: number; readonly hash: string } | { readonly error: string } {
+	const idx = anchor.indexOf("#");
+	if (idx < 1) {
+		return { error: `Invalid anchor format: "${anchor}". Expected "LINE#HASH" (e.g. "42#VK").` };
+	}
+
+	const lineStr = anchor.slice(0, idx);
+	const hash = anchor.slice(idx + 1);
+
+	const line = Number.parseInt(lineStr, 10);
+	if (!Number.isFinite(line) || line < 1) {
+		return { error: `Invalid line number in anchor "${anchor}". Must be >= 1.` };
+	}
+
+	if (hash.length !== 2 || !CID_SET.has(hash[0]) || !CID_SET.has(hash[1])) {
+		return {
+			error: `Invalid hash "${hash}" in anchor "${anchor}". Must be 2 chars from CID alphabet.`,
+		};
+	}
+
+	return { line, hash };
+}
+
+// --- Types ---
+
+interface HashlineEdit {
+	readonly op: "replace" | "append" | "prepend";
+	readonly pos: string; // "LINE#HASH" anchor
+	readonly end?: string; // End anchor for range replace
+	readonly lines: string | readonly string[] | null; // null = delete
+}
+
+interface HashlineEditArgs {
+	readonly file: string;
+	readonly edits: readonly HashlineEdit[];
+}
+
+// --- Helpers ---
+
+function formatAnchor(lineNum: number, content: string): string {
+	return `${lineNum}#${computeLineHash(content)}`;
+}
+
+function getSurroundingAnchors(
+	fileLines: readonly string[],
+	lineIdx: number,
+	radius: number,
+): string {
+	const anchors: string[] = [];
+	const start = Math.max(0, lineIdx - radius);
+	const end = Math.min(fileLines.length - 1, lineIdx + radius);
+	for (let i = start; i <= end; i++) {
+		anchors.push(`  ${formatAnchor(i + 1, fileLines[i])} ${fileLines[i]}`);
+	}
+	return anchors.join("\n");
+}
+
+function toLineArray(lines: string | readonly string[] | null): readonly string[] | null {
+	if (lines === null) return null;
+	if (typeof lines === "string") return [lines];
+	return lines;
+}
+
+// --- Core function ---
+
+export async function hashlineEditCore(args: HashlineEditArgs): Promise<string> {
+	// Path safety: require absolute paths to prevent relative path confusion
+	if (!isAbsolute(args.file)) {
+		return `Error: File path must be absolute. Got: "${args.file}"`;
+	}
+	const resolved = resolve(args.file);
+
+	if (args.edits.length === 0) {
+		return "Applied 0 edit(s) — no changes made.";
+	}
+
+	let raw: string;
+	try {
+		raw = await readFile(resolved, "utf-8");
+	} catch (err) {
+		return `Error: Cannot read file "${resolved}": ${err instanceof Error ? err.message : String(err)}`;
+	}
+
+	// Split preserving trailing newline behavior
+	const hasTrailingNewline = raw.endsWith("\n");
+	const fileLines = raw.split("\n");
+	// If file ends with newline, split produces an extra empty string at the end — remove it
+	if (hasTrailingNewline && fileLines[fileLines.length - 1] === "") {
+		fileLines.pop();
+	}
+
+	// Parse all anchors first and validate
+	const parsedEdits: Array<{
+		readonly op: "replace" | "append" | "prepend";
+		readonly lineIdx: number;
+		readonly hash: string;
+		readonly endLineIdx?: number;
+		readonly endHash?: string;
+		readonly lines: readonly string[] | null;
+	}> = [];
+
+	const errors: string[] = [];
+
+	for (const edit of args.edits) {
+		const parsed = parseAnchor(edit.pos);
+		if ("error" in parsed) {
+			errors.push(parsed.error);
+			continue;
+		}
+
+		const lineIdx = parsed.line - 1; // Convert to 0-based
+		if (lineIdx >= fileLines.length) {
+			errors.push(`Line ${parsed.line} is out of bounds (file has ${fileLines.length} lines).`);
+			continue;
+		}
+
+		let endLineIdx: number | undefined;
+		let endHash: string | undefined;
+
+		if (edit.end) {
+			const parsedEnd = parseAnchor(edit.end);
+			if ("error" in parsedEnd) {
+				errors.push(parsedEnd.error);
+				continue;
+			}
+			endLineIdx = parsedEnd.line - 1;
+			endHash = parsedEnd.hash;
+			if (endLineIdx >= fileLines.length) {
+				errors.push(
+					`End line ${parsedEnd.line} is out of bounds (file has ${fileLines.length} lines).`,
+				);
+				continue;
+			}
+			if (endLineIdx < lineIdx) {
+				errors.push(`End line ${parsedEnd.line} is before start line ${parsed.line}.`);
+				continue;
+			}
+		}
+
+		parsedEdits.push({
+			op: edit.op,
+			lineIdx,
+			hash: parsed.hash,
+			endLineIdx,
+			endHash,
+			lines: toLineArray(edit.lines),
+		});
+	}
+
+	if (errors.length > 0) {
+		return `Error: ${errors.join("\n")}`;
+	}
+
+	// Validate hashes against current file content
+	const hashErrors: string[] = [];
+
+	for (const edit of parsedEdits) {
+		const actualHash = computeLineHash(fileLines[edit.lineIdx]);
+		if (actualHash !== edit.hash) {
+			const surrounding = getSurroundingAnchors(fileLines, edit.lineIdx, 2);
+			hashErrors.push(
+				`Hash mismatch at line ${edit.lineIdx + 1}: expected ${edit.hash}, actual ${actualHash}.\nUpdated anchors:\n${surrounding}`,
+			);
+		}
+
+		if (edit.endLineIdx !== undefined && edit.endHash !== undefined) {
+			const actualEndHash = computeLineHash(fileLines[edit.endLineIdx]);
+			if (actualEndHash !== edit.endHash) {
+				const surrounding = getSurroundingAnchors(fileLines, edit.endLineIdx, 2);
+				hashErrors.push(
+					`Hash mismatch at end line ${edit.endLineIdx + 1}: expected ${edit.endHash}, actual ${actualEndHash}.\nUpdated anchors:\n${surrounding}`,
+				);
+			}
+		}
+	}
+
+	if (hashErrors.length > 0) {
+		return `Error: Stale edit(s) detected.\n${hashErrors.join("\n\n")}`;
+	}
+
+	// Detect overlapping edits — reject before applying any mutations
+	for (let i = 0; i < parsedEdits.length; i++) {
+		const a = parsedEdits[i];
+		const aStart = a.lineIdx;
+		const aEnd = a.endLineIdx ?? a.lineIdx;
+		for (let j = i + 1; j < parsedEdits.length; j++) {
+			const b = parsedEdits[j];
+			const bStart = b.lineIdx;
+			const bEnd = b.endLineIdx ?? b.lineIdx;
+			if (aStart <= bEnd && bStart <= aEnd) {
+				return `Error: Overlapping edits at lines ${aStart + 1}-${aEnd + 1} and ${bStart + 1}-${bEnd + 1}. Split into separate calls.`;
+			}
+		}
+	}
+
+	// Sort edits bottom-up (highest line index first) to prevent drift
+	const sortedEdits = [...parsedEdits].sort((a, b) => {
+		const aLine = a.endLineIdx ?? a.lineIdx;
+		const bLine = b.endLineIdx ?? b.lineIdx;
+		return bLine - aLine;
+	});
+
+	// Apply edits
+	for (const edit of sortedEdits) {
+		const newLines = edit.lines;
+
+		switch (edit.op) {
+			case "replace": {
+				if (edit.endLineIdx !== undefined) {
+					// Range replace: remove from lineIdx to endLineIdx (inclusive), insert newLines
+					const count = edit.endLineIdx - edit.lineIdx + 1;
+					if (newLines === null) {
+						fileLines.splice(edit.lineIdx, count);
+					} else {
+						fileLines.splice(edit.lineIdx, count, ...newLines);
+					}
+				} else {
+					// Single line replace
+					if (newLines === null) {
+						fileLines.splice(edit.lineIdx, 1);
+					} else {
+						fileLines.splice(edit.lineIdx, 1, ...newLines);
+					}
+				}
+				break;
+			}
+			case "append": {
+				const insertLines = newLines ?? [];
+				fileLines.splice(edit.lineIdx + 1, 0, ...insertLines);
+				break;
+			}
+			case "prepend": {
+				const insertLines = newLines ?? [];
+				fileLines.splice(edit.lineIdx, 0, ...insertLines);
+				break;
+			}
+		}
+	}
+
+	// Write back
+	const output = fileLines.join("\n") + (hasTrailingNewline ? "\n" : "");
+	try {
+		await writeFile(resolved, output, "utf-8");
+	} catch (err) {
+		return `Error: Cannot write file "${resolved}": ${err instanceof Error ? err.message : String(err)}`;
+	}
+
+	return `Applied ${sortedEdits.length} edit(s) to ${resolved}.`;
+}
+
+// --- Tool wrapper ---
+
+export const ocHashlineEdit = tool({
+	description:
+		"Edit files using hash-anchored line references (LINE#ID format). Validates line content hasn't changed before applying edits. Supports replace, append, and prepend operations.",
+	args: {
+		file: tool.schema.string().describe("Absolute path to the file to edit"),
+		edits: tool.schema
+			.array(
+				tool.schema.object({
+					op: tool.schema.enum(["replace", "append", "prepend"]).describe("Edit operation type"),
+					pos: tool.schema.string().describe("LINE#HASH anchor, e.g. '42#VK'"),
+					end: tool.schema
+						.string()
+						.optional()
+						.describe("End anchor for range replace, e.g. '48#SN'"),
+					lines: tool.schema
+						.union([
+							tool.schema.string(),
+							tool.schema.array(tool.schema.string()),
+							tool.schema.null(),
+						])
+						.describe("New content (string, string[], or null to delete)"),
+				}),
+			)
+			.describe("Array of edit operations to apply"),
+	},
+	async execute(args) {
+		return hashlineEditCore(args);
+	},
+});