@kodrunhq/opencode-autopilot 1.15.2 → 1.16.0

package/src/projects/repository.ts

@@ -0,0 +1,264 @@
+import type { Database } from "bun:sqlite";
+import { getMemoryDb } from "../memory/database";
+import {
+	gitFingerprintInputSchema,
+	projectGitFingerprintSchema,
+	projectPathRecordSchema,
+	projectRecordSchema,
+} from "./schemas";
+import type {
+	GitFingerprintInput,
+	ProjectGitFingerprint,
+	ProjectPathRecord,
+	ProjectRecord,
+} from "./types";
+
+interface ProjectRow {
+	readonly id: string;
+	readonly path: string;
+	readonly name: string;
+	readonly first_seen_at: string | null;
+	readonly last_updated: string;
+}
+
+interface ProjectPathRow {
+	readonly project_id: string;
+	readonly path: string;
+	readonly first_seen_at: string;
+	readonly last_updated: string;
+	readonly is_current: number;
+}
+
+interface ProjectFingerprintRow {
+	readonly project_id: string;
+	readonly normalized_remote_url: string;
+	readonly default_branch: string | null;
+	readonly first_seen_at: string;
+	readonly last_updated: string;
+}
+
+function resolveDb(db?: Database): Database {
+	return db ?? getMemoryDb();
+}
+
+function withWriteTransaction<T>(db: Database, callback: () => T): T {
+	const row = db.query("PRAGMA transaction_state").get() as { transaction_state?: string } | null;
+	const isAlreadyInTransaction = row?.transaction_state === "TRANSACTION";
+	if (isAlreadyInTransaction) {
+		return callback();
+	}
+
+	db.run("BEGIN IMMEDIATE");
+	try {
+		const result = callback();
+		db.run("COMMIT");
+		return result;
+	} catch (error: unknown) {
+		try {
+			db.run("ROLLBACK");
+		} catch {
+			// Ignore rollback failures so the original error wins.
+		}
+		throw error;
+	}
+}
+
+function rowToProject(row: ProjectRow): ProjectRecord {
+	return projectRecordSchema.parse({
+		id: row.id,
+		path: row.path,
+		name: row.name,
+		firstSeenAt: row.first_seen_at ?? row.last_updated,
+		lastUpdated: row.last_updated,
+	});
+}
+
+function rowToProjectPath(row: ProjectPathRow): ProjectPathRecord {
+	return projectPathRecordSchema.parse({
+		projectId: row.project_id,
+		path: row.path,
+		firstSeenAt: row.first_seen_at,
+		lastUpdated: row.last_updated,
+		isCurrent: row.is_current === 1,
+	});
+}
+
+function rowToProjectFingerprint(row: ProjectFingerprintRow): ProjectGitFingerprint {
+	return projectGitFingerprintSchema.parse({
+		projectId: row.project_id,
+		normalizedRemoteUrl: row.normalized_remote_url,
+		defaultBranch: row.default_branch,
+		firstSeenAt: row.first_seen_at,
+		lastUpdated: row.last_updated,
+	});
+}
+
+export function upsertProjectRecord(project: ProjectRecord, db?: Database): ProjectRecord {
+	const validated = projectRecordSchema.parse(project);
+	const d = resolveDb(db);
+	const firstSeenAt = validated.firstSeenAt ?? validated.lastUpdated;
+
+	withWriteTransaction(d, () => {
+		d.run(
+			`INSERT INTO projects (id, path, name, first_seen_at, last_updated)
+			 VALUES (?, ?, ?, ?, ?)
+			 ON CONFLICT(id) DO UPDATE SET
+				path = excluded.path,
+				name = excluded.name,
+				first_seen_at = COALESCE(projects.first_seen_at, excluded.first_seen_at),
+				last_updated = excluded.last_updated`,
+			[validated.id, validated.path, validated.name, firstSeenAt, validated.lastUpdated],
+		);
+
+		d.run("UPDATE project_paths SET is_current = 0, last_updated = ? WHERE project_id = ?", [
+			validated.lastUpdated,
+			validated.id,
+		]);
+		d.run(
+			`INSERT INTO project_paths (project_id, path, first_seen_at, last_updated, is_current)
+			 VALUES (?, ?, ?, ?, 1)
+			 ON CONFLICT(project_id, path) DO UPDATE SET
+				last_updated = excluded.last_updated,
+				is_current = 1`,
+			[validated.id, validated.path, firstSeenAt, validated.lastUpdated],
+		);
+	});
+
+	return projectRecordSchema.parse({
+		...validated,
+		firstSeenAt,
+	});
+}
+
+export function getProjectById(projectId: string, db?: Database): ProjectRecord | null {
+	const d = resolveDb(db);
+	const row = d.query("SELECT * FROM projects WHERE id = ?").get(projectId) as ProjectRow | null;
+	return row ? rowToProject(row) : null;
+}
+
+export function getProjectByCurrentPath(path: string, db?: Database): ProjectRecord | null {
+	const d = resolveDb(db);
+	const row = d.query("SELECT * FROM projects WHERE path = ?").get(path) as ProjectRow | null;
+	return row ? rowToProject(row) : null;
+}
+
+export function getProjectByAnyPath(path: string, db?: Database): ProjectRecord | null {
+	const current = getProjectByCurrentPath(path, db);
+	if (current !== null) {
+		return current;
+	}
+
+	const d = resolveDb(db);
+	const row = d
+		.query(
+			`SELECT p.*
+			 FROM project_paths pp
+			 JOIN projects p ON p.id = pp.project_id
+			 WHERE pp.path = ?
+			 ORDER BY pp.is_current DESC, pp.last_updated DESC
+			 LIMIT 1`,
+		)
+		.get(path) as ProjectRow | null;
+	return row ? rowToProject(row) : null;
+}
+
+export function listProjectPaths(projectId: string, db?: Database): readonly ProjectPathRecord[] {
+	const d = resolveDb(db);
+	const rows = d
+		.query(
+			`SELECT *
+			 FROM project_paths
+			 WHERE project_id = ?
+			 ORDER BY is_current DESC, last_updated DESC, path ASC`,
+		)
+		.all(projectId) as ProjectPathRow[];
+	return Object.freeze(rows.map(rowToProjectPath));
+}
+
+export function setProjectCurrentPath(
+	projectId: string,
+	path: string,
+	name: string,
+	seenAt: string,
+	db?: Database,
+): ProjectRecord {
+	const d = resolveDb(db);
+	const existing = getProjectById(projectId, d);
+	if (existing === null) {
+		throw new Error(`Unknown project id: ${projectId}`);
+	}
+
+	const next = projectRecordSchema.parse({
+		id: existing.id,
+		path,
+		name,
+		firstSeenAt: existing.firstSeenAt,
+		lastUpdated: seenAt,
+	});
+	return upsertProjectRecord(next, d);
+}
+
+export function upsertProjectGitFingerprint(
+	projectId: string,
+	fingerprint: GitFingerprintInput,
+	seenAt: string,
+	db?: Database,
+): ProjectGitFingerprint {
+	const validated = gitFingerprintInputSchema.parse(fingerprint);
+	const d = resolveDb(db);
+
+	d.run(
+		`INSERT INTO project_git_fingerprints (
+			project_id,
+			normalized_remote_url,
+			default_branch,
+			first_seen_at,
+			last_updated
+		) VALUES (?, ?, ?, ?, ?)
+		ON CONFLICT(project_id, normalized_remote_url) DO UPDATE SET
+			default_branch = excluded.default_branch,
+			last_updated = excluded.last_updated`,
+		[projectId, validated.normalizedRemoteUrl, validated.defaultBranch, seenAt, seenAt],
+	);
+
+	return projectGitFingerprintSchema.parse({
+		projectId,
+		normalizedRemoteUrl: validated.normalizedRemoteUrl,
+		defaultBranch: validated.defaultBranch,
+		firstSeenAt: seenAt,
+		lastUpdated: seenAt,
+	});
+}
+
+export function getProjectsByGitFingerprint(
+	normalizedRemoteUrl: string,
+	db?: Database,
+): readonly ProjectRecord[] {
+	const d = resolveDb(db);
+	const rows = d
+		.query(
+			`SELECT DISTINCT p.*
+			 FROM project_git_fingerprints pgf
+			 JOIN projects p ON p.id = pgf.project_id
+			 WHERE pgf.normalized_remote_url = ?
+			 ORDER BY p.last_updated DESC, p.id DESC`,
+		)
+		.all(normalizedRemoteUrl) as ProjectRow[];
+	return Object.freeze(rows.map(rowToProject));
+}
+
+export function listProjectGitFingerprints(
+	projectId: string,
+	db?: Database,
+): readonly ProjectGitFingerprint[] {
+	const d = resolveDb(db);
+	const rows = d
+		.query(
+			`SELECT *
+			 FROM project_git_fingerprints
+			 WHERE project_id = ?
+			 ORDER BY last_updated DESC, normalized_remote_url ASC`,
+		)
+		.all(projectId) as ProjectFingerprintRow[];
+	return Object.freeze(rows.map(rowToProjectFingerprint));
+}

package/src/projects/resolve.ts

@@ -0,0 +1,301 @@
+import type { Database } from "bun:sqlite";
+import { execFile as execFileCb, execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import { promisify } from "node:util";
+import {
+	getProjectByAnyPath,
+	getProjectByCurrentPath,
+	getProjectsByGitFingerprint,
+	setProjectCurrentPath,
+	upsertProjectGitFingerprint,
+	upsertProjectRecord,
+} from "./repository";
+import { projectRecordSchema } from "./schemas";
+import type { GitFingerprintInput, ProjectRecord } from "./types";
+
+const execFile = promisify(execFileCb);
+
+export interface ProjectResolverDeps {
+	readonly db?: Database;
+	readonly now?: () => string;
+	readonly createProjectId?: () => string;
+	readonly readGitFingerprint?: (projectRoot: string) => Promise<GitFingerprintInput | null>;
+}
+
+export function normalizeGitRemoteUrl(remoteUrl: string): string | null {
+	const trimmed = remoteUrl.trim();
+	if (trimmed.length === 0) {
+		return null;
+	}
+
+	const scpMatch = trimmed.match(/^([^@\s]+)@([^:\s]+):(.+)$/);
+	if (scpMatch) {
+		const [, _user, host, path] = scpMatch;
+		const normalizedPath = path.replace(/\.git$/i, "").replace(/^\/+/, "");
+		return `${host.toLowerCase()}/${normalizedPath}`;
+	}
+
+	try {
+		const parsed = new URL(trimmed);
+		const normalizedPath = parsed.pathname.replace(/\.git$/i, "").replace(/^\/+/, "");
+		if (normalizedPath.length === 0) {
+			return null;
+		}
+		return `${parsed.host.toLowerCase()}/${normalizedPath}`;
+	} catch {
+		const normalized = trimmed.replace(/\.git$/i, "").replace(/^\/+/, "");
+		return normalized.length > 0 ? normalized : null;
+	}
+}
+
+async function readGitCommand(
+	projectRoot: string,
+	args: readonly string[],
+): Promise<string | null> {
+	try {
+		const { stdout } = await execFile("git", args, {
+			cwd: projectRoot,
+			timeout: 5000,
+		});
+		const trimmed = stdout.trim();
+		return trimmed.length > 0 ? trimmed : null;
+	} catch {
+		return null;
+	}
+}
+
+function readGitCommandSync(projectRoot: string, args: readonly string[]): string | null {
+	try {
+		const stdout = execFileSync("git", args, {
+			cwd: projectRoot,
+			timeout: 5000,
+			encoding: "utf-8",
+		});
+		const trimmed = stdout.trim();
+		return trimmed.length > 0 ? trimmed : null;
+	} catch {
+		return null;
+	}
+}
+
+export async function readProjectGitFingerprint(
+	projectRoot: string,
+): Promise<GitFingerprintInput | null> {
+	const remoteUrl = await readGitCommand(projectRoot, ["config", "--get", "remote.origin.url"]);
+	if (remoteUrl === null) {
+		return null;
+	}
+
+	const normalizedRemoteUrl = normalizeGitRemoteUrl(remoteUrl);
+	if (normalizedRemoteUrl === null) {
+		return null;
+	}
+
+	const remoteHead = await readGitCommand(projectRoot, [
+		"symbolic-ref",
+		"--short",
+		"refs/remotes/origin/HEAD",
+	]);
+	const defaultBranch =
+		remoteHead === null ? null : remoteHead.split("/").slice(1).join("/") || null;
+
+	return {
+		normalizedRemoteUrl,
+		defaultBranch,
+	};
+}
+
+export function readProjectGitFingerprintSync(projectRoot: string): GitFingerprintInput | null {
+	const remoteUrl = readGitCommandSync(projectRoot, ["config", "--get", "remote.origin.url"]);
+	if (remoteUrl === null) {
+		return null;
+	}
+
+	const normalizedRemoteUrl = normalizeGitRemoteUrl(remoteUrl);
+	if (normalizedRemoteUrl === null) {
+		return null;
+	}
+
+	const remoteHead = readGitCommandSync(projectRoot, [
+		"symbolic-ref",
+		"--short",
+		"refs/remotes/origin/HEAD",
+	]);
+	const defaultBranch =
+		remoteHead === null ? null : remoteHead.split("/").slice(1).join("/") || null;
+
+	return {
+		normalizedRemoteUrl,
+		defaultBranch,
+	};
+}
+
+export interface SyncProjectResolverDeps {
+	readonly db?: Database;
+	readonly now?: () => string;
+	readonly createProjectId?: () => string;
+	readonly readGitFingerprint?: (projectRoot: string) => GitFingerprintInput | null;
+	readonly allowCreate?: boolean;
+}
+
+export async function resolveProjectIdentity(
+	projectRoot: string,
+	deps: ProjectResolverDeps = {},
+): Promise<ProjectRecord> {
+	const now = deps.now ?? (() => new Date().toISOString());
+	const createProjectId = deps.createProjectId ?? (() => randomUUID());
+	const readGitFingerprint = deps.readGitFingerprint ?? readProjectGitFingerprint;
+	const seenAt = now();
+	const projectName = basename(projectRoot);
+
+	const current = getProjectByCurrentPath(projectRoot, deps.db);
+	if (current !== null) {
+		const updated = upsertProjectRecord(
+			{
+				...current,
+				name: projectName,
+				lastUpdated: seenAt,
+			},
+			deps.db,
+		);
+		const fingerprint = await readGitFingerprint(projectRoot);
+		if (fingerprint !== null) {
+			upsertProjectGitFingerprint(updated.id, fingerprint, seenAt, deps.db);
+		}
+		return updated;
+	}
+
+	const historical = getProjectByAnyPath(projectRoot, deps.db);
+	if (historical !== null) {
+		const updated = setProjectCurrentPath(historical.id, projectRoot, projectName, seenAt, deps.db);
+		const fingerprint = await readGitFingerprint(projectRoot);
+		if (fingerprint !== null) {
+			upsertProjectGitFingerprint(updated.id, fingerprint, seenAt, deps.db);
+		}
+		return updated;
+	}
+
+	const fingerprint = await readGitFingerprint(projectRoot);
+	if (fingerprint !== null) {
+		const matches = getProjectsByGitFingerprint(fingerprint.normalizedRemoteUrl, deps.db);
+		if (matches.length === 1) {
+			const updated = setProjectCurrentPath(
+				matches[0].id,
+				projectRoot,
+				projectName,
+				seenAt,
+				deps.db,
+			);
+			upsertProjectGitFingerprint(updated.id, fingerprint, seenAt, deps.db);
+			return updated;
+		}
+	}
+
+	const created = upsertProjectRecord(
+		{
+			id: createProjectId(),
+			path: projectRoot,
+			name: projectName,
+			firstSeenAt: seenAt,
+			lastUpdated: seenAt,
+		},
+		deps.db,
+	);
+	if (fingerprint !== null) {
+		upsertProjectGitFingerprint(created.id, fingerprint, seenAt, deps.db);
+	}
+	return created;
+}
+
+export function resolveProjectIdentitySync(
+	projectRoot: string,
+	deps: SyncProjectResolverDeps = {},
+): ProjectRecord {
+	const now = deps.now ?? (() => new Date().toISOString());
+	const createProjectId = deps.createProjectId ?? (() => randomUUID());
+	const readGitFingerprint = deps.readGitFingerprint ?? readProjectGitFingerprintSync;
+	const allowCreate = deps.allowCreate ?? true;
+	const seenAt = now();
+	const projectName = basename(projectRoot);
+
+	const current = getProjectByCurrentPath(projectRoot, deps.db);
+	if (current !== null) {
+		if (!allowCreate) {
+			return current;
+		}
+
+		const updated = upsertProjectRecord(
+			{
+				...current,
+				name: projectName,
+				lastUpdated: seenAt,
+			},
+			deps.db,
+		);
+		const fingerprint = readGitFingerprint(projectRoot);
+		if (fingerprint !== null) {
+			upsertProjectGitFingerprint(updated.id, fingerprint, seenAt, deps.db);
+		}
+		return updated;
+	}
+
+	const historical = getProjectByAnyPath(projectRoot, deps.db);
+	if (historical !== null) {
+		if (!allowCreate) {
+			return historical;
+		}
+
+		const updated = setProjectCurrentPath(historical.id, projectRoot, projectName, seenAt, deps.db);
+		const fingerprint = readGitFingerprint(projectRoot);
+		if (fingerprint !== null) {
+			upsertProjectGitFingerprint(updated.id, fingerprint, seenAt, deps.db);
+		}
+		return updated;
+	}
+
+	const fingerprint = readGitFingerprint(projectRoot);
+	if (fingerprint !== null) {
+		const matches = getProjectsByGitFingerprint(fingerprint.normalizedRemoteUrl, deps.db);
+		if (matches.length === 1) {
+			if (!allowCreate) {
+				return matches[0];
+			}
+
+			const updated = setProjectCurrentPath(
+				matches[0].id,
+				projectRoot,
+				projectName,
+				seenAt,
+				deps.db,
+			);
+			upsertProjectGitFingerprint(updated.id, fingerprint, seenAt, deps.db);
+			return updated;
+		}
+	}
+
+	if (!allowCreate) {
+		return projectRecordSchema.parse({
+			id: `project:${projectRoot}`,
+			path: projectRoot,
+			name: projectName,
+			firstSeenAt: seenAt,
+			lastUpdated: seenAt,
+		});
+	}
+
+	const created = upsertProjectRecord(
+		{
+			id: createProjectId(),
+			path: projectRoot,
+			name: projectName,
+			firstSeenAt: seenAt,
+			lastUpdated: seenAt,
+		},
+		deps.db,
+	);
+	if (fingerprint !== null) {
+		upsertProjectGitFingerprint(created.id, fingerprint, seenAt, deps.db);
+	}
+	return created;
+}

package/src/projects/schemas.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+
+export const projectRecordSchema = z.object({
+	id: z.string().min(1).max(128),
+	path: z.string().min(1).max(4096),
+	name: z.string().min(1).max(256),
+	firstSeenAt: z.string().min(1).max(128).optional(),
+	lastUpdated: z.string().min(1).max(128),
+});
+
+export const projectPathRecordSchema = z.object({
+	projectId: z.string().min(1).max(128),
+	path: z.string().min(1).max(4096),
+	firstSeenAt: z.string().min(1).max(128),
+	lastUpdated: z.string().min(1).max(128),
+	isCurrent: z.boolean(),
+});
+
+export const projectGitFingerprintSchema = z.object({
+	projectId: z.string().min(1).max(128),
+	normalizedRemoteUrl: z.string().min(1).max(2048),
+	defaultBranch: z.string().min(1).max(256).nullable(),
+	firstSeenAt: z.string().min(1).max(128),
+	lastUpdated: z.string().min(1).max(128),
+});
+
+export const gitFingerprintInputSchema = z.object({
+	normalizedRemoteUrl: z.string().min(1).max(2048),
+	defaultBranch: z.string().min(1).max(256).nullable().default(null),
+});

package/src/projects/types.ts

@@ -0,0 +1,12 @@
+import type { z } from "zod";
+import type {
+	gitFingerprintInputSchema,
+	projectGitFingerprintSchema,
+	projectPathRecordSchema,
+	projectRecordSchema,
+} from "./schemas";
+
+export type ProjectRecord = z.infer<typeof projectRecordSchema>;
+export type ProjectPathRecord = z.infer<typeof projectPathRecordSchema>;
+export type ProjectGitFingerprint = z.infer<typeof projectGitFingerprintSchema>;
+export type GitFingerprintInput = z.infer<typeof gitFingerprintInputSchema>;

package/src/review/memory.ts

@@ -1,8 +1,9 @@
 /**
  * Per-project review memory persistence.
  *
- * Stores recent findings and false positives at
- * {projectRoot}/.opencode-autopilot/review-memory.json
+ * Stores recent findings and false positives in the project kernel,
+ * with {projectRoot}/.opencode-autopilot/review-memory.json kept as a
+ * compatibility mirror/export during the Phase 4 migration window.
  *
  * Memory is pruned on load to cap storage and remove stale entries.
  * All writes are atomic (tmp file + rename) to prevent corruption.
@@ -10,7 +11,9 @@
 
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
+import { loadReviewMemoryFromKernel, saveReviewMemoryToKernel } from "../kernel/repository";
 import { ensureDir, isEnoentError } from "../utils/fs-helpers";
+import { getProjectArtifactDir } from "../utils/paths";
 import { reviewMemorySchema } from "./schemas";
 import type { ReviewMemory } from "./types";
 
@@ -20,6 +23,7 @@ const MEMORY_FILE = "review-memory.json";
 const MAX_FINDINGS = 100;
 const MAX_FALSE_POSITIVES = 50;
 const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+let legacyReviewMemoryMirrorWarned = false;
 
 /**
  * Create a valid empty memory object.
@@ -42,12 +46,19 @@ export function createEmptyMemory(): ReviewMemory {
  * Prunes on load to cap storage.
  */
 export async function loadReviewMemory(projectRoot: string): Promise<ReviewMemory | null> {
+	const kernelMemory = loadReviewMemoryFromKernel(getProjectArtifactDir(projectRoot));
+	if (kernelMemory !== null) {
+		return pruneMemory(kernelMemory);
+	}
+
 	const memoryPath = join(projectRoot, ".opencode-autopilot", MEMORY_FILE);
 	try {
 		const raw = await readFile(memoryPath, "utf-8");
 		const parsed = JSON.parse(raw);
 		const validated = reviewMemorySchema.parse(parsed);
-		return pruneMemory(validated);
+		const pruned = pruneMemory(validated);
+		saveReviewMemoryToKernel(getProjectArtifactDir(projectRoot), pruned);
+		return pruned;
 	} catch (error: unknown) {
 		if (isEnoentError(error)) {
 			return null;
@@ -70,12 +81,21 @@ export async function loadReviewMemory(projectRoot: string): Promise<ReviewMemor
  */
 export async function saveReviewMemory(memory: ReviewMemory, projectRoot: string): Promise<void> {
 	const validated = reviewMemorySchema.parse(memory);
-	const dir = join(projectRoot, ".opencode-autopilot");
-	await ensureDir(dir);
-	const memoryPath = join(dir, MEMORY_FILE);
-	const tmpPath = `${memoryPath}.tmp.${Date.now()}`;
-	await writeFile(tmpPath, JSON.stringify(validated, null, 2), "utf-8");
-	await rename(tmpPath, memoryPath);
+	saveReviewMemoryToKernel(getProjectArtifactDir(projectRoot), validated);
+
+	try {
+		const dir = join(projectRoot, ".opencode-autopilot");
+		await ensureDir(dir);
+		const memoryPath = join(dir, MEMORY_FILE);
+		const tmpPath = `${memoryPath}.tmp.${Date.now()}`;
+		await writeFile(tmpPath, JSON.stringify(validated, null, 2), "utf-8");
+		await rename(tmpPath, memoryPath);
+	} catch (error: unknown) {
+		if (!legacyReviewMemoryMirrorWarned) {
+			legacyReviewMemoryMirrorWarned = true;
+			console.warn("[opencode-autopilot] review-memory.json mirror write failed:", error);
+		}
+	}
 }
 
 /**