@kodrunhq/opencode-autopilot 1.4.0 → 1.6.0

package/src/skills/adaptive-injector.ts

@@ -0,0 +1,122 @@
+/**
+ * Adaptive skill injection: project stack detection, skill filtering, and
+ * multi-skill context building with dependency ordering and token budget.
+ *
+ * Complements detectStackTags (which works on file paths from git diff)
+ * by checking the project root for manifest files. This enables skill
+ * filtering even before any git diff is available.
+ */
+
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { sanitizeTemplateContent } from "../review/sanitize";
+import { resolveDependencyOrder } from "./dependency-resolver";
+import type { LoadedSkill } from "./loader";
+
+const DEFAULT_TOKEN_BUDGET = 8000;
+/** Rough estimate: 1 token ~ 4 chars */
+const CHARS_PER_TOKEN = 4;
+
+/**
+ * Manifest files that indicate project stack.
+ * Checks project root for these files to detect the stack.
+ */
+const MANIFEST_TAGS: Readonly<Record<string, readonly string[]>> = Object.freeze({
+	"package.json": Object.freeze(["javascript"]),
+	"tsconfig.json": Object.freeze(["typescript"]),
+	"bunfig.toml": Object.freeze(["bun", "typescript"]),
+	"bun.lockb": Object.freeze(["bun"]),
+	"go.mod": Object.freeze(["go"]),
+	"Cargo.toml": Object.freeze(["rust"]),
+	"pyproject.toml": Object.freeze(["python"]),
+	"requirements.txt": Object.freeze(["python"]),
+	Pipfile: Object.freeze(["python"]),
+	Gemfile: Object.freeze(["ruby"]),
+});
+
+/**
+ * Detect project stack tags from manifest files in the project root.
+ * Complements detectStackTags (which works on file paths from git diff).
+ */
+export async function detectProjectStackTags(projectRoot: string): Promise<readonly string[]> {
+	const results = await Promise.all(
+		Object.entries(MANIFEST_TAGS).map(async ([manifest, manifestTags]) => {
+			try {
+				await access(join(projectRoot, manifest));
+				return [...manifestTags];
+			} catch {
+				return [];
+			}
+		}),
+	);
+
+	return [...new Set(results.flat())];
+}
+
+/**
+ * Filter skills by detected stack tags.
+ * Skills with empty stacks are ALWAYS included (methodology skills).
+ * Skills with non-empty stacks are included only if at least one tag matches.
+ */
+export function filterSkillsByStack(
+	skills: ReadonlyMap<string, LoadedSkill>,
+	tags: readonly string[],
+): ReadonlyMap<string, LoadedSkill> {
+	const tagSet = new Set(tags);
+	const filtered = new Map<string, LoadedSkill>();
+
+	for (const [name, skill] of skills) {
+		if (skill.frontmatter.stacks.length === 0) {
+			filtered.set(name, skill);
+		} else if (skill.frontmatter.stacks.some((s) => tagSet.has(s))) {
+			filtered.set(name, skill);
+		}
+	}
+
+	return filtered;
+}
+
+/**
+ * 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.
+ */
+export function buildMultiSkillContext(
+	skills: ReadonlyMap<string, LoadedSkill>,
+	tokenBudget: number = DEFAULT_TOKEN_BUDGET,
+): string {
+	if (skills.size === 0) return "";
+
+	// Resolve dependency order
+	const depMap = new Map(
+		[...skills.entries()].map(([name, skill]) => [name, { requires: skill.frontmatter.requires }]),
+	);
+	const { ordered, cycles } = resolveDependencyOrder(depMap);
+
+	// Skip cycle participants (graceful degradation)
+	const cycleSet = new Set(cycles);
+	const validOrder = ordered.filter((name) => !cycleSet.has(name));
+
+	// Build context with token budget enforcement
+	const charBudget = tokenBudget * CHARS_PER_TOKEN;
+	let totalChars = 0;
+	const sections: string[] = [];
+
+	for (const name of validOrder) {
+		const skill = skills.get(name);
+		if (!skill) continue;
+
+		const collapsed = skill.content.replace(/[\r\n]+/g, " ");
+		const header = `[Skill: ${name}]\n`;
+		const separator = sections.length > 0 ? 2 : 0; // "\n\n"
+		const sectionCost = collapsed.length + header.length + separator;
+		if (totalChars + sectionCost > charBudget) break;
+
+		const sanitized = sanitizeTemplateContent(collapsed);
+		sections.push(`${header}${sanitized}`);
+		totalChars += sectionCost;
+	}
+
+	if (sections.length === 0) return "";
+	return `\n\nSkills context (follow these conventions and methodologies):\n${sections.join("\n\n")}`;
+}

package/src/skills/dependency-resolver.ts

@@ -0,0 +1,88 @@
+/**
+ * Topological sort with cycle detection for skill dependencies.
+ *
+ * Uses iterative DFS-based topological ordering. Skills not in the map are
+ * silently skipped (graceful degradation). All cycle participants are reported
+ * in the `cycles` array so callers can exclude them.
+ */
+
+export interface DependencyNode {
+	readonly requires: readonly string[];
+}
+
+export interface ResolutionResult {
+	readonly ordered: readonly string[];
+	readonly cycles: readonly string[];
+}
+
+/** Hard cap on skill count to prevent DoS via crafted dependency chains. */
+const MAX_SKILLS = 500;
+
+/**
+ * Iterative topological sort with cycle detection.
+ * Skills not in the map are silently skipped (graceful degradation).
+ * All nodes participating in a cycle are reported (not just the re-entry point).
+ */
+export function resolveDependencyOrder(
+	skills: ReadonlyMap<string, DependencyNode>,
+): ResolutionResult {
+	if (skills.size > MAX_SKILLS) {
+		return { ordered: [], cycles: [...skills.keys()] };
+	}
+
+	const visited = new Set<string>();
+	const inStack = new Set<string>();
+	const stackArr: string[] = [];
+	const ordered: string[] = [];
+	const cycleSet = new Set<string>();
+
+	for (const startName of skills.keys()) {
+		if (visited.has(startName)) continue;
+
+		// Iterative DFS using explicit stack
+		const dfsStack: Array<{ name: string; depIndex: number }> = [{ name: startName, depIndex: 0 }];
+		inStack.add(startName);
+		visited.add(startName);
+		stackArr.push(startName);
+
+		while (dfsStack.length > 0) {
+			const frame = dfsStack[dfsStack.length - 1];
+			const skill = skills.get(frame.name);
+			const deps = skill ? skill.requires : [];
+
+			if (frame.depIndex < deps.length) {
+				const dep = deps[frame.depIndex];
+				frame.depIndex++;
+
+				if (!skills.has(dep)) continue; // skip unknown deps
+
+				if (inStack.has(dep)) {
+					// Cycle detected — record all nodes in the cycle path
+					const cycleStart = stackArr.indexOf(dep);
+					for (let i = cycleStart; i < stackArr.length; i++) {
+						cycleSet.add(stackArr[i]);
+					}
+					continue;
+				}
+
+				if (!visited.has(dep)) {
+					visited.add(dep);
+					inStack.add(dep);
+					stackArr.push(dep);
+					dfsStack.push({ name: dep, depIndex: 0 });
+				}
+			} else {
+				// All deps processed — pop this node
+				dfsStack.pop();
+				inStack.delete(frame.name);
+				stackArr.pop();
+				ordered.push(frame.name);
+			}
+		}
+	}
+
+	return Object.freeze({
+		ordered: Object.freeze(ordered),
+		cycles: Object.freeze([...cycleSet]),
+	});
+}

package/src/skills/linter.ts

@@ -0,0 +1,113 @@
+import { parse } from "yaml";
+
+interface LintResult {
+	readonly valid: boolean;
+	readonly errors: readonly string[];
+	readonly warnings: readonly string[];
+}
+
+/** Parse YAML frontmatter from markdown content. Supports LF and CRLF. */
+function extractFrontmatter(content: string): Record<string, unknown> | null {
+	const match = content.match(/^---\r?\n([\s\S]*?\r?\n)?---/);
+	if (!match) return null;
+	try {
+		const parsed = parse(match[1] ?? "");
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+		return parsed as Record<string, unknown>;
+	} catch {
+		return null;
+	}
+}
+
+/** Freeze a LintResult including nested arrays. */
+function freezeResult(valid: boolean, errors: string[], warnings: string[]): LintResult {
+	return Object.freeze({
+		valid,
+		errors: Object.freeze(errors),
+		warnings: Object.freeze(warnings),
+	});
+}
+
+/** Lint a skill SKILL.md file for valid YAML frontmatter and required fields. */
+export function lintSkill(content: string): LintResult {
+	const errors: string[] = [];
+	const warnings: string[] = [];
+
+	const fm = extractFrontmatter(content);
+	if (!fm) {
+		return freezeResult(false, ["Missing YAML frontmatter"], []);
+	}
+
+	// Required fields
+	if (typeof fm.name !== "string" || fm.name.length === 0) {
+		errors.push("Missing required field: name");
+	}
+	if (typeof fm.description !== "string" || fm.description.length === 0) {
+		errors.push("Missing required field: description");
+	}
+
+	// Optional but recommended fields
+	if (!Array.isArray(fm.stacks)) {
+		warnings.push(
+			"Missing recommended field: stacks (add stacks: [] for methodology skills or stacks: [lang] for language skills)",
+		);
+	}
+	if (!Array.isArray(fm.requires)) {
+		warnings.push("Missing recommended field: requires (add requires: [] if no dependencies)");
+	}
+
+	// Validate stacks entries are strings
+	if (Array.isArray(fm.stacks) && fm.stacks.some((s: unknown) => typeof s !== "string")) {
+		errors.push("stacks must contain only strings");
+	}
+	if (Array.isArray(fm.requires) && fm.requires.some((s: unknown) => typeof s !== "string")) {
+		errors.push("requires must contain only strings");
+	}
+
+	// Content validation (CRLF-safe)
+	const body = content.replace(/^---\r?\n(?:[\s\S]*?\r?\n)?---/, "").trim();
+	if (body.length === 0) {
+		warnings.push("Skill has no content after frontmatter");
+	}
+
+	return freezeResult(errors.length === 0, errors, warnings);
+}
+
+/** Lint a command markdown file for valid YAML frontmatter and required fields. */
+export function lintCommand(content: string): LintResult {
+	const errors: string[] = [];
+	const warnings: string[] = [];
+
+	const fm = extractFrontmatter(content);
+	if (!fm) {
+		return freezeResult(false, ["Missing YAML frontmatter"], []);
+	}
+
+	if (typeof fm.description !== "string" || fm.description.length === 0) {
+		errors.push("Missing required field: description");
+	}
+
+	const body = content.replace(/^---\r?\n(?:[\s\S]*?\r?\n)?---/, "").trim();
+	if (body.length === 0) {
+		warnings.push("Command has no content after frontmatter");
+	}
+
+	return freezeResult(errors.length === 0, errors, warnings);
+}
+
+/** Lint an agent markdown file for valid YAML frontmatter and required fields. */
+export function lintAgent(content: string): LintResult {
+	const errors: string[] = [];
+	const warnings: string[] = [];
+
+	const fm = extractFrontmatter(content);
+	if (!fm) {
+		return freezeResult(false, ["Missing YAML frontmatter"], []);
+	}
+
+	if (typeof fm.name !== "string" || fm.name.length === 0) {
+		errors.push("Missing required field: name");
+	}
+
+	return freezeResult(errors.length === 0, errors, warnings);
+}

package/src/skills/loader.ts

@@ -0,0 +1,88 @@
+/**
+ * Skill frontmatter parser and file loader.
+ *
+ * Loads SKILL.md files from the global skills directory, parses their
+ * YAML frontmatter, and returns structured skill metadata + content.
+ * Uses the `yaml` package for parsing (not regex — per "Don't Hand-Roll" guideline).
+ */
+
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse } from "yaml";
+import { isEnoentError } from "../utils/fs-helpers";
+
+export interface SkillFrontmatter {
+	readonly name: string;
+	readonly description: string;
+	readonly stacks: readonly string[];
+	readonly requires: readonly string[];
+}
+
+export interface LoadedSkill {
+	readonly frontmatter: SkillFrontmatter;
+	readonly content: string;
+	readonly path: string;
+}
+
+/**
+ * Parse YAML frontmatter from SKILL.md content.
+ * Returns null if no valid frontmatter block is found or parsing fails.
+ */
+export function parseSkillFrontmatter(content: string): SkillFrontmatter | null {
+	const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+	if (!match) return null;
+
+	try {
+		const parsed = parse(match[1]);
+		if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+		const fm = parsed as Record<string, unknown>;
+		return {
+			name: typeof fm.name === "string" ? fm.name : "",
+			description: typeof fm.description === "string" ? fm.description : "",
+			stacks: Array.isArray(fm.stacks)
+				? fm.stacks.filter((s): s is string => typeof s === "string")
+				: [],
+			requires: Array.isArray(fm.requires)
+				? fm.requires.filter((s): s is string => typeof s === "string")
+				: [],
+		};
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Load all skills from a base directory (e.g., ~/.config/opencode/skills/).
+ * Returns a map of skill name -> LoadedSkill. Best-effort: skips invalid skills.
+ */
+export async function loadAllSkills(skillsDir: string): Promise<ReadonlyMap<string, LoadedSkill>> {
+	const skills = new Map<string, LoadedSkill>();
+
+	try {
+		const entries = await readdir(skillsDir, { withFileTypes: true });
+		await Promise.all(
+			entries
+				.filter((e) => e.isDirectory() && e.name !== ".gitkeep")
+				.map(async (dir) => {
+					try {
+						const skillPath = join(skillsDir, dir.name, "SKILL.md");
+						const content = await readFile(skillPath, "utf-8");
+						const fm = parseSkillFrontmatter(content);
+						if (fm?.name) {
+							skills.set(fm.name, { frontmatter: fm, content, path: skillPath });
+						}
+					} catch (error: unknown) {
+						// Skip ENOENT/IO errors (expected for invalid skills)
+						if (!isEnoentError(error) && !(error instanceof SyntaxError)) {
+							const errObj = error as { code?: unknown };
+							if (typeof errObj?.code !== "string") throw error;
+						}
+					}
+				}),
+		);
+	} catch (error: unknown) {
+		if (!isEnoentError(error)) throw error;
+	}
+
+	return skills;
+}

package/src/templates/skill-template.ts

@@ -5,12 +5,16 @@ export interface SkillTemplateInput {
 	readonly description: string;
 	readonly license?: string;
 	readonly compatibility?: string;
+	readonly stacks?: readonly string[];
+	readonly requires?: readonly string[];
 }
 
 export function generateSkillMarkdown(input: SkillTemplateInput): string {
 	const frontmatter: Record<string, unknown> = {
 		name: input.name,
 		description: input.description,
+		stacks: input.stacks ?? [],
+		requires: input.requires ?? [],
 		...(input.license !== undefined && { license: input.license }),
 		...(input.compatibility !== undefined && { compatibility: input.compatibility }),
 	};

package/src/tools/configure.ts

@@ -314,7 +314,7 @@ async function handleCommit(configPath?: string): Promise<string> {
 	}
 	const newConfig = {
 		...currentConfig,
-		version: 4 as const,
+		version: 5 as const,
 		configured: true,
 		groups: groupsRecord,
 		overrides: currentConfig.overrides ?? {},

package/src/tools/create-skill.ts

@@ -11,6 +11,8 @@ interface CreateSkillArgs {
 	readonly description: string;
 	readonly license?: string;
 	readonly compatibility?: string;
+	readonly stacks?: readonly string[];
+	readonly requires?: readonly string[];
 }
 
 export async function createSkillCore(args: CreateSkillArgs, baseDir: string): Promise<string> {
@@ -27,6 +29,8 @@ export async function createSkillCore(args: CreateSkillArgs, baseDir: string): P
 		description: args.description,
 		license: args.license,
 		compatibility: args.compatibility,
+		stacks: args.stacks,
+		requires: args.requires,
 	});
 
 	try {
@@ -67,6 +71,14 @@ export const ocCreateSkill = tool({
 			.max(64)
 			.optional()
 			.describe("Compatibility (e.g., 'opencode')"),
+		stacks: tool.schema
+			.array(tool.schema.string())
+			.optional()
+			.describe("Stack tags for adaptive loading (e.g., ['typescript', 'bun'])"),
+		requires: tool.schema
+			.array(tool.schema.string())
+			.optional()
+			.describe("Required skill dependencies (e.g., ['coding-standards'])"),
 	},
 	async execute(args) {
 		return createSkillCore(args, getGlobalConfigDir());

package/src/tools/memory-status.ts

@@ -0,0 +1,164 @@
+/**
+ * oc_memory_status tool — inspect memory system state.
+ *
+ * Shows observation counts, storage size, recent observations,
+ * preferences, and per-type breakdowns. Follows the *Core + tool()
+ * pattern from create-agent.ts.
+ *
+ * @module
+ */
+
+import { Database } from "bun:sqlite";
+import { statSync } from "node:fs";
+import { join } from "node:path";
+import { tool } from "@opencode-ai/plugin";
+import { DB_FILE, MEMORY_DIR, OBSERVATION_TYPES } from "../memory/constants";
+import { getMemoryDb } from "../memory/database";
+import { getAllPreferences } from "../memory/repository";
+import { getGlobalConfigDir } from "../utils/paths";
+
+interface MemoryStatusResult {
+	readonly stats: {
+		readonly totalObservations: number;
+		readonly totalProjects: number;
+		readonly totalPreferences: number;
+		readonly storageSizeKb: number;
+		readonly observationsByType: Record<string, number>;
+	} | null;
+	readonly recentObservations: readonly {
+		readonly type: string;
+		readonly summary: string;
+		readonly createdAt: string;
+		readonly confidence: number;
+	}[];
+	readonly preferences: readonly {
+		readonly key: string;
+		readonly value: string;
+		readonly confidence: number;
+	}[];
+	readonly error?: string;
+}
+
+/**
+ * Core function for memory status inspection.
+ * Accepts a Database instance for testability (or uses the singleton).
+ */
+export function memoryStatusCore(
+	_args: { readonly detail?: "summary" | "full" },
+	dbOrPath?: Database | string,
+): MemoryStatusResult {
+	let ownedDb: Database | null = null;
+	try {
+		if (typeof dbOrPath === "string") {
+			ownedDb = new Database(dbOrPath);
+		}
+		const db = dbOrPath instanceof Database ? dbOrPath : (ownedDb ?? getMemoryDb());
+
+		// Count observations
+		const obsCountRow = db.query("SELECT COUNT(*) as cnt FROM observations").get() as {
+			cnt: number;
+		};
+		const totalObservations = obsCountRow.cnt;
+
+		// Count by type
+		const typeRows = db
+			.query("SELECT type, COUNT(*) as cnt FROM observations GROUP BY type")
+			.all() as Array<{ type: string; cnt: number }>;
+
+		const observationsByType: Record<string, number> = {};
+		for (const t of OBSERVATION_TYPES) {
+			observationsByType[t] = 0;
+		}
+		for (const row of typeRows) {
+			observationsByType[row.type] = row.cnt;
+		}
+
+		// Count projects
+		const projCountRow = db.query("SELECT COUNT(*) as cnt FROM projects").get() as {
+			cnt: number;
+		};
+		const totalProjects = projCountRow.cnt;
+
+		// Count preferences
+		const prefCountRow = db.query("SELECT COUNT(*) as cnt FROM preferences").get() as {
+			cnt: number;
+		};
+		const totalPreferences = prefCountRow.cnt;
+
+		// Storage size — derive from actual DB path, not always the global default
+		let storageSizeKb = 0;
+		try {
+			const statPath =
+				typeof dbOrPath === "string" && dbOrPath !== ":memory:"
+					? dbOrPath
+					: join(getGlobalConfigDir(), MEMORY_DIR, DB_FILE);
+			const stat = statSync(statPath);
+			storageSizeKb = Math.round(stat.size / 1024);
+		} catch {
+			// DB might be in-memory or path doesn't exist
+		}
+
+		// Recent observations (last 10)
+		const recentRows = db
+			.query(
+				"SELECT type, summary, created_at, confidence FROM observations ORDER BY created_at DESC LIMIT 10",
+			)
+			.all() as Array<{
+			type: string;
+			summary: string;
+			created_at: string;
+			confidence: number;
+		}>;
+
+		const recentObservations = recentRows.map((row) => ({
+			type: row.type,
+			summary: row.summary,
+			createdAt: row.created_at,
+			confidence: row.confidence,
+		}));
+
+		// All preferences
+		const allPrefs = getAllPreferences(db);
+		const preferences = allPrefs.map((p) => ({
+			key: p.key,
+			value: p.value,
+			confidence: p.confidence,
+		}));
+
+		return {
+			stats: {
+				totalObservations,
+				totalProjects,
+				totalPreferences,
+				storageSizeKb,
+				observationsByType,
+			},
+			recentObservations,
+			preferences,
+		};
+	} catch (err) {
+		const detail = err instanceof Error ? err.message : String(err);
+		return {
+			stats: null,
+			recentObservations: [],
+			preferences: [],
+			error: `Memory system error: ${detail}`,
+		};
+	} finally {
+		ownedDb?.close();
+	}
+}
+
+export const ocMemoryStatus = tool({
+	description:
+		"Show memory system status: observation counts, recent memories, preferences, and storage size.",
+	args: {
+		detail: tool.schema
+			.enum(["summary", "full"])
+			.default("summary")
+			.describe("Level of detail to show"),
+	},
+	async execute(args) {
+		return JSON.stringify(memoryStatusCore(args), null, 2);
+	},
+});