@kodrunhq/opencode-autopilot 1.5.0 → 1.7.0

package/src/orchestrator/skill-injection.ts

@@ -82,9 +82,9 @@ export async function loadAdaptiveSkillContext(
 
 		const matchingSkills = filterSkillsByStack(allSkills, projectTags);
 		return buildMultiSkillContext(matchingSkills, tokenBudget);
-	} catch (error: unknown) {
-		// Best-effort for I/O errors; re-throw programmer errors
-		if (error instanceof TypeError || error instanceof RangeError) throw error;
+	} catch {
+		// Best-effort: all errors return empty string. Caller (injectSkillContext)
+		// logs the error — no need to re-throw since the call site is also best-effort.
 		return "";
 	}
 }

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/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);
+	},
+});

package/src/tools/orchestrate.ts

@@ -5,7 +5,7 @@ import type { DispatchResult } from "../orchestrator/handlers/types";
 import { buildLessonContext } from "../orchestrator/lesson-injection";
 import { loadLessonMemory } from "../orchestrator/lesson-memory";
 import { completePhase, getNextPhase } from "../orchestrator/phase";
-import { buildSkillContext, loadSkillContent } from "../orchestrator/skill-injection";
+import { loadAdaptiveSkillContext } from "../orchestrator/skill-injection";
 import { createInitialState, loadState, patchState, saveState } from "../orchestrator/state";
 import type { Phase } from "../orchestrator/types";
 import { isEnoentError } from "../utils/fs-helpers";
@@ -96,17 +96,16 @@ async function injectLessonContext(
 }
 
 /**
- * Attempt to inject coding-standards skill context into a dispatch prompt.
+ * Attempt to inject stack-filtered adaptive skill context into a dispatch prompt.
  * Best-effort: failures are silently swallowed to avoid breaking dispatch.
  */
-async function injectSkillContext(prompt: string): Promise<string> {
+async function injectSkillContext(prompt: string, projectRoot?: string): Promise<string> {
 	try {
 		const baseDir = getGlobalConfigDir();
-		const content = await loadSkillContent(baseDir);
-		const ctx = buildSkillContext(content);
+		const ctx = await loadAdaptiveSkillContext(baseDir, projectRoot ?? process.cwd());
 		if (ctx) return prompt + ctx;
-	} catch {
-		// Best-effort: swallow all errors (same as lesson injection)
+	} catch (err) {
+		console.warn("[opencode-autopilot] skill injection failed:", err);
 	}
 	return prompt;
 }
@@ -146,7 +145,7 @@ async function processHandlerResult(
 					handlerResult.phase,
 					artifactDir,
 				);
-				const withSkills = await injectSkillContext(enrichedPrompt);
+				const withSkills = await injectSkillContext(enrichedPrompt, join(artifactDir, ".."));
 				if (withSkills !== handlerResult.prompt) {
 					return JSON.stringify({ ...handlerResult, prompt: withSkills });
 				}
@@ -163,7 +162,7 @@ async function processHandlerResult(
 					handlerResult.phase as string,
 					artifactDir,
 				);
-				const skillSuffix = await injectSkillContext("");
+				const skillSuffix = await injectSkillContext("", join(artifactDir, ".."));
 				const combinedSuffix = lessonSuffix + (skillSuffix || "");
 				if (combinedSuffix) {
 					const enrichedAgents = handlerResult.agents.map((entry) => ({