@danypops/papyrus 0.47.2 → 0.48.0

package/src/stores/in-memory-project-registry-store.ts

@@ -0,0 +1,100 @@
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import { TASK_PROJECT_ALIAS_MAX_COUNT } from "../constants.ts";
+import type { Project, RegisterProjectInput } from "../domain/project-registry.ts";
+import type { ProjectRegistryStore } from "../ports/project-registry-store.ts";
+
+export function uniqueAliases(values: readonly string[], name: string): string[] {
+	const seen = new Set([name.trim().toLowerCase()]);
+	const aliases = values.flatMap((value) => {
+		const trimmed = value.trim();
+		const key = trimmed.toLowerCase();
+		if (!trimmed || seen.has(key)) return [];
+		seen.add(key);
+		return [trimmed];
+	});
+	if (aliases.length > TASK_PROJECT_ALIAS_MAX_COUNT) {
+		throw new Error(`project aliases cannot exceed ${TASK_PROJECT_ALIAS_MAX_COUNT} entries`);
+	}
+	return aliases;
+}
+
+/**
+ * Extracted from what was TaskScopeStore's own project-registry bookkeeping (project list/exact
+ * resolve/register/rename/move) -- moving a registered project's root must rewrite every
+ * consumer's own rows keyed by that root (Task's own TaskProjectScope/TaskViewPreference,
+ * and independently an ArtifactScopeStore's own membership rows), and more than one consumer
+ * can share a single registry instance specifically so they resolve against identical project
+ * identities. subscribeRootMoved supports that: every subscriber is notified, not just the
+ * first, so sharing one instance across TaskScopeStore and ArtifactScopeStore never silently
+ * drops the other's rewrite.
+ */
+export class InMemoryProjectRegistryStore implements ProjectRegistryStore {
+	private readonly projectRows = new Map<string, Project>();
+	private readonly rootMovedListeners: Array<(previousRoot: string, nextRoot: string) => void> = [];
+
+	subscribeRootMoved(listener: (previousRoot: string, nextRoot: string) => void): void {
+		this.rootMovedListeners.push(listener);
+	}
+
+	projects(query: string | undefined, limit: number): Project[] {
+		const needle = query?.trim().toLowerCase();
+		return [...this.projectRows.values()]
+			.filter(
+				(project) =>
+					!needle ||
+					project.name.toLowerCase().includes(needle) ||
+					project.projectRoot.toLowerCase().includes(needle) ||
+					project.aliases.some((alias) => alias.toLowerCase().includes(needle)),
+			)
+			.sort((left, right) => left.name.localeCompare(right.name) || left.projectRoot.localeCompare(right.projectRoot))
+			.slice(0, limit);
+	}
+
+	matchingProjects(reference: string): Project[] {
+		const needle = reference.trim().toLowerCase();
+		return [...this.projectRows.values()]
+			.filter(
+				(project) =>
+					project.id.toLowerCase() === needle ||
+					project.name.toLowerCase() === needle ||
+					project.projectRoot.toLowerCase() === needle ||
+					project.aliases.some((alias) => alias.toLowerCase() === needle),
+			)
+			.slice(0, 11);
+	}
+
+	registerProject(input: RegisterProjectInput): Project {
+		const now = new Date().toISOString();
+		const byRoot = [...this.projectRows.values()].find((project) => project.projectRoot === input.projectRoot);
+		const existing = input.existingId ? this.projectRows.get(input.existingId) : byRoot;
+		const name = input.name?.trim() || existing?.name || basename(input.projectRoot) || input.projectRoot;
+		const aliases = uniqueAliases(
+			[...(existing?.aliases ?? []), ...(existing && existing.name !== name ? [existing.name] : []), ...(input.aliases ?? [])],
+			name,
+		);
+		const project: Project = {
+			id: existing?.id ?? randomUUID(),
+			name,
+			aliases,
+			projectRoot: input.projectRoot,
+			createdAt: existing?.createdAt ?? now,
+			updatedAt: now,
+		};
+		if (existing && existing.projectRoot !== project.projectRoot) {
+			for (const listener of this.rootMovedListeners) listener(existing.projectRoot, project.projectRoot);
+		}
+		this.projectRows.set(project.id, project);
+		return project;
+	}
+
+	/** Exposed for a caller (e.g. InMemoryTaskScopeStore) that needs to look up a project by its exact current root without going through the bounded matchingProjects search. */
+	byRoot(projectRoot: string): Project | undefined {
+		return [...this.projectRows.values()].find((project) => project.projectRoot === projectRoot);
+	}
+
+	/** Exposed for a caller (e.g. InMemoryArtifactScopeStore) that needs a project's own current fields (its root, for the legacy single-root compatibility view) from a stored membership id, without going through the needle-matching matchingProjects search. */
+	byId(id: string): Project | undefined {
+		return this.projectRows.get(id);
+	}
+}

package/src/stores/sqlite-project-registry-store.ts

@@ -0,0 +1,132 @@
+import { randomUUID } from "node:crypto";
+import { basename } from "node:path";
+import type { Db } from "../db.ts";
+import { inTransaction } from "../db.ts";
+import type { Project, RegisterProjectInput } from "../domain/project-registry.ts";
+import type { ProjectRegistryStore } from "../ports/project-registry-store.ts";
+import { uniqueAliases } from "./in-memory-project-registry-store.ts";
+
+interface ProjectRow {
+	id: string;
+	name: string;
+	aliases_json: string;
+	project_root: string;
+	created_at: string;
+	updated_at: string;
+}
+
+function projectFromRow(row: ProjectRow): Project {
+	return {
+		id: row.id,
+		name: row.name,
+		aliases: JSON.parse(row.aliases_json) as string[],
+		projectRoot: row.project_root,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+	};
+}
+
+/**
+ * Backed by `task_projects` -- the same table name Task's own migration (v26) established --
+ * kept as-is rather than renamed, so an existing database's registered project ids/names/roots
+ * survive this extraction with zero migration. Kind-neutral in behavior: nothing here reads or
+ * writes a Task-shaped row: onRootMoved lets a composing store (TaskScopeStore,
+ * ArtifactScopeStore) react to a root move for its own kind-specific rows in the same
+ * transaction, without this store needing to know either of them exist.
+ */
+export class SQLiteProjectRegistryStore implements ProjectRegistryStore {
+	constructor(
+		private readonly db: Db,
+		private readonly onRootMoved?: (db: Db, previousRoot: string, nextRoot: string) => void,
+	) {}
+
+	projects(query: string | undefined, limit: number): Project[] {
+		const needle = query?.trim().toLowerCase();
+		if (!needle) {
+			return (
+				this.db
+					.prepare(
+						"SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects ORDER BY name, project_root LIMIT ?",
+					)
+					.all(limit) as ProjectRow[]
+			).map(projectFromRow);
+		}
+		return (
+			this.db
+				.prepare(`
+					SELECT id, name, aliases_json, project_root, created_at, updated_at
+					FROM task_projects
+					WHERE instr(lower(name), ?) > 0
+						OR instr(lower(project_root), ?) > 0
+						OR EXISTS (
+							SELECT 1 FROM json_each(task_projects.aliases_json)
+							WHERE instr(lower(CAST(json_each.value AS TEXT)), ?) > 0
+						)
+					ORDER BY name, project_root
+					LIMIT ?
+				`)
+				.all(needle, needle, needle, limit) as ProjectRow[]
+		).map(projectFromRow);
+	}
+
+	matchingProjects(reference: string): Project[] {
+		const needle = reference.trim().toLowerCase();
+		return (
+			this.db
+				.prepare(`
+					SELECT id, name, aliases_json, project_root, created_at, updated_at
+					FROM task_projects
+					WHERE lower(id) = ? OR lower(name) = ? OR lower(project_root) = ?
+						OR EXISTS (
+							SELECT 1 FROM json_each(task_projects.aliases_json)
+							WHERE lower(CAST(json_each.value AS TEXT)) = ?
+						)
+					ORDER BY name, project_root
+					LIMIT 11
+				`)
+				.all(needle, needle, needle, needle) as ProjectRow[]
+		).map(projectFromRow);
+	}
+
+	registerProject(input: RegisterProjectInput): Project {
+		return inTransaction(this.db, () => {
+			const row = (
+				input.existingId
+					? this.db
+							.prepare("SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects WHERE id = ?")
+							.get(input.existingId)
+					: this.db
+							.prepare("SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects WHERE project_root = ?")
+							.get(input.projectRoot)
+			) as ProjectRow | null;
+			const existing = row ? projectFromRow(row) : undefined;
+			const now = new Date().toISOString();
+			const name = input.name?.trim() || existing?.name || basename(input.projectRoot) || input.projectRoot;
+			const aliases = uniqueAliases(
+				[...(existing?.aliases ?? []), ...(existing && existing.name !== name ? [existing.name] : []), ...(input.aliases ?? [])],
+				name,
+			);
+			const project: Project = {
+				id: existing?.id ?? randomUUID(),
+				name,
+				aliases,
+				projectRoot: input.projectRoot,
+				createdAt: existing?.createdAt ?? now,
+				updatedAt: now,
+			};
+			if (existing && existing.projectRoot !== project.projectRoot) this.onRootMoved?.(this.db, existing.projectRoot, project.projectRoot);
+			this.db
+				.prepare(`
+					INSERT INTO task_projects (id, name, aliases_json, project_root, created_at, updated_at)
+					VALUES (?, ?, ?, ?, ?, ?)
+					ON CONFLICT(id) DO UPDATE SET
+						name = excluded.name,
+						aliases_json = excluded.aliases_json,
+						project_root = excluded.project_root,
+						updated_at = excluded.updated_at
+				`)
+				.run(project.id, project.name, JSON.stringify(project.aliases), project.projectRoot, project.createdAt, project.updatedAt);
+			return project;
+		});
+	}
+}

package/src/stores/sqlite-task-scope-store.ts

@@ -1,6 +1,3 @@
-import { randomUUID } from "node:crypto";
-import { basename } from "node:path";
-import { TASK_PROJECT_ALIAS_MAX_COUNT } from "../constants.ts";
 import type { Db } from "../db.ts";
 import { inTransaction } from "../db.ts";
 import type {
@@ -11,45 +8,21 @@ import type {
 	TaskViewMode,
 	TaskViewPreference,
 } from "../domain/task-scope.ts";
+import { SQLiteProjectRegistryStore } from "./sqlite-project-registry-store.ts";
 import type { TaskScopeStore } from "./task-scope-store.ts";
 
-interface ProjectRow {
-	id: string;
-	name: string;
-	aliases_json: string;
-	project_root: string;
-	created_at: string;
-	updated_at: string;
+/** Rewrites every task_scopes/task_views row pinned to a project root that just moved -- called inside the same registerProject() transaction, so a rename/move is atomic with the rewrite. */
+function rewriteTaskRowsForMovedRoot(db: Db, previousRoot: string, nextRoot: string): void {
+	db.prepare("UPDATE task_scopes SET project_root = ? WHERE project_root = ?").run(nextRoot, previousRoot);
+	db.prepare("UPDATE task_views SET project_root = ? WHERE project_root = ?").run(nextRoot, previousRoot);
 }
 
-function projectFromRow(row: ProjectRow): TaskProject {
-	return {
-		id: row.id,
-		name: row.name,
-		aliases: JSON.parse(row.aliases_json) as string[],
-		projectRoot: row.project_root,
-		createdAt: row.created_at,
-		updatedAt: row.updated_at,
-	};
-}
+export class SQLiteTaskScopeStore implements TaskScopeStore {
+	private readonly registry: SQLiteProjectRegistryStore;
 
-function uniqueAliases(values: readonly string[], name: string): string[] {
-	const seen = new Set([name.trim().toLowerCase()]);
-	const aliases = values.flatMap((value) => {
-		const trimmed = value.trim();
-		const key = trimmed.toLowerCase();
-		if (!trimmed || seen.has(key)) return [];
-		seen.add(key);
-		return [trimmed];
-	});
-	if (aliases.length > TASK_PROJECT_ALIAS_MAX_COUNT) {
-		throw new Error(`project aliases cannot exceed ${TASK_PROJECT_ALIAS_MAX_COUNT} entries`);
+	constructor(private readonly db: Db) {
+		this.registry = new SQLiteProjectRegistryStore(db, rewriteTaskRowsForMovedRoot);
 	}
-	return aliases;
-}
-
-export class SQLiteTaskScopeStore implements TaskScopeStore {
-	constructor(private readonly db: Db) {}
 
 	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope {
 		inTransaction(this.db, () => {
@@ -115,95 +88,14 @@ export class SQLiteTaskScopeStore implements TaskScopeStore {
 	}
 
 	projects(query: string | undefined, limit: number): TaskProject[] {
-		const needle = query?.trim().toLowerCase();
-		if (!needle) {
-			return (
-				this.db
-					.prepare(
-						"SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects ORDER BY name, project_root LIMIT ?",
-					)
-					.all(limit) as ProjectRow[]
-			).map(projectFromRow);
-		}
-		return (
-			this.db
-				.prepare(`
-					SELECT id, name, aliases_json, project_root, created_at, updated_at
-					FROM task_projects
-					WHERE instr(lower(name), ?) > 0
-						OR instr(lower(project_root), ?) > 0
-						OR EXISTS (
-							SELECT 1 FROM json_each(task_projects.aliases_json)
-							WHERE instr(lower(CAST(json_each.value AS TEXT)), ?) > 0
-						)
-					ORDER BY name, project_root
-					LIMIT ?
-				`)
-				.all(needle, needle, needle, limit) as ProjectRow[]
-		).map(projectFromRow);
+		return this.registry.projects(query, limit);
 	}
 
 	matchingProjects(reference: string): TaskProject[] {
-		const needle = reference.trim().toLowerCase();
-		return (
-			this.db
-				.prepare(`
-					SELECT id, name, aliases_json, project_root, created_at, updated_at
-					FROM task_projects
-					WHERE lower(id) = ? OR lower(name) = ? OR lower(project_root) = ?
-						OR EXISTS (
-							SELECT 1 FROM json_each(task_projects.aliases_json)
-							WHERE lower(CAST(json_each.value AS TEXT)) = ?
-						)
-					ORDER BY name, project_root
-					LIMIT 11
-				`)
-				.all(needle, needle, needle, needle) as ProjectRow[]
-		).map(projectFromRow);
+		return this.registry.matchingProjects(reference);
 	}
 
 	registerProject(input: RegisterTaskProjectInput): TaskProject {
-		return inTransaction(this.db, () => {
-			const row = (
-				input.existingId
-					? this.db
-							.prepare("SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects WHERE id = ?")
-							.get(input.existingId)
-					: this.db
-							.prepare("SELECT id, name, aliases_json, project_root, created_at, updated_at FROM task_projects WHERE project_root = ?")
-							.get(input.projectRoot)
-			) as ProjectRow | null;
-			const existing = row ? projectFromRow(row) : undefined;
-			const now = new Date().toISOString();
-			const name = input.name?.trim() || existing?.name || basename(input.projectRoot) || input.projectRoot;
-			const aliases = uniqueAliases(
-				[...(existing?.aliases ?? []), ...(existing && existing.name !== name ? [existing.name] : []), ...(input.aliases ?? [])],
-				name,
-			);
-			const project: TaskProject = {
-				id: existing?.id ?? randomUUID(),
-				name,
-				aliases,
-				projectRoot: input.projectRoot,
-				createdAt: existing?.createdAt ?? now,
-				updatedAt: now,
-			};
-			if (existing && existing.projectRoot !== project.projectRoot) {
-				this.db.prepare("UPDATE task_scopes SET project_root = ? WHERE project_root = ?").run(project.projectRoot, existing.projectRoot);
-				this.db.prepare("UPDATE task_views SET project_root = ? WHERE project_root = ?").run(project.projectRoot, existing.projectRoot);
-			}
-			this.db
-				.prepare(`
-					INSERT INTO task_projects (id, name, aliases_json, project_root, created_at, updated_at)
-					VALUES (?, ?, ?, ?, ?, ?)
-					ON CONFLICT(id) DO UPDATE SET
-						name = excluded.name,
-						aliases_json = excluded.aliases_json,
-						project_root = excluded.project_root,
-						updated_at = excluded.updated_at
-				`)
-				.run(project.id, project.name, JSON.stringify(project.aliases), project.projectRoot, project.createdAt, project.updatedAt);
-			return project;
-		});
+		return this.registry.registerProject(input);
 	}
 }

package/src/stores/task-scope-store.ts

@@ -1,6 +1,3 @@
-import { randomUUID } from "node:crypto";
-import { basename } from "node:path";
-import { TASK_PROJECT_ALIAS_MAX_COUNT } from "../constants.ts";
 import type {
 	RegisterTaskProjectInput,
 	TaskProject,
@@ -9,6 +6,8 @@ import type {
 	TaskViewMode,
 	TaskViewPreference,
 } from "../domain/task-scope.ts";
+import type { ProjectRegistryStore } from "../ports/project-registry-store.ts";
+import { InMemoryProjectRegistryStore } from "./in-memory-project-registry-store.ts";
 
 export interface TaskScopeStore {
 	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope;
@@ -21,32 +20,38 @@ export interface TaskScopeStore {
 	registerProject(input: RegisterTaskProjectInput): TaskProject;
 }
 
-function uniqueAliases(values: readonly string[], name: string): string[] {
-	const seen = new Set([name.trim().toLowerCase()]);
-	const aliases = values.flatMap((value) => {
-		const trimmed = value.trim();
-		const key = trimmed.toLowerCase();
-		if (!trimmed || seen.has(key)) return [];
-		seen.add(key);
-		return [trimmed];
-	});
-	if (aliases.length > TASK_PROJECT_ALIAS_MAX_COUNT) {
-		throw new Error(`project aliases cannot exceed ${TASK_PROJECT_ALIAS_MAX_COUNT} entries`);
-	}
-	return aliases;
-}
-
+/**
+ * Task's own scope/view bookkeeping, composing a ProjectRegistryStore for the project-catalog
+ * methods (projects/matchingProjects/registerProject) rather than implementing that bookkeeping
+ * itself -- see project-registry-store.ts. Pass a shared registry instance to keep Task and a
+ * non-Task ArtifactScopeStore resolving against the exact same project identities; omitted, this
+ * store gets its own private one (matching this class's own behavior before the extraction).
+ */
 export class InMemoryTaskScopeStore implements TaskScopeStore {
 	private readonly scopes = new Map<string, TaskProjectScope>();
 	private readonly views = new Map<string, TaskViewPreference>();
-	private readonly projectRows = new Map<string, TaskProject>();
+	private readonly registry: InMemoryProjectRegistryStore;
+
+	constructor(registry?: ProjectRegistryStore) {
+		this.registry = registry instanceof InMemoryProjectRegistryStore ? registry : new InMemoryProjectRegistryStore();
+		this.registry.subscribeRootMoved((previousRoot, nextRoot) => this.onRootMoved(previousRoot, nextRoot));
+	}
+
+	private onRootMoved(previousRoot: string, nextRoot: string): void {
+		for (const [taskId, scope] of this.scopes) {
+			if (scope.projectRoot === previousRoot) this.scopes.set(taskId, { ...scope, projectRoot: nextRoot });
+		}
+		const view = this.views.get(previousRoot);
+		if (view) {
+			this.views.delete(previousRoot);
+			this.views.set(nextRoot, { ...view, projectRoot: nextRoot });
+		}
+	}
 
 	assign(taskId: string, projectRoot: string | undefined, source: TaskScopeSource): TaskProjectScope {
 		const scope = { taskId, ...(projectRoot === undefined ? {} : { projectRoot }), source };
 		this.scopes.set(taskId, scope);
-		if (projectRoot !== undefined && ![...this.projectRows.values()].some((project) => project.projectRoot === projectRoot)) {
-			this.registerProject({ projectRoot });
-		}
+		if (projectRoot !== undefined && !this.registry.byRoot(projectRoot)) this.registerProject({ projectRoot });
 		return scope;
 	}
 
@@ -73,60 +78,14 @@ export class InMemoryTaskScopeStore implements TaskScopeStore {
 	}
 
 	projects(query: string | undefined, limit: number): TaskProject[] {
-		const needle = query?.trim().toLowerCase();
-		return [...this.projectRows.values()]
-			.filter(
-				(project) =>
-					!needle ||
-					project.name.toLowerCase().includes(needle) ||
-					project.projectRoot.toLowerCase().includes(needle) ||
-					project.aliases.some((alias) => alias.toLowerCase().includes(needle)),
-			)
-			.sort((left, right) => left.name.localeCompare(right.name) || left.projectRoot.localeCompare(right.projectRoot))
-			.slice(0, limit);
+		return this.registry.projects(query, limit);
 	}
 
 	matchingProjects(reference: string): TaskProject[] {
-		const needle = reference.trim().toLowerCase();
-		return [...this.projectRows.values()]
-			.filter(
-				(project) =>
-					project.id.toLowerCase() === needle ||
-					project.name.toLowerCase() === needle ||
-					project.projectRoot.toLowerCase() === needle ||
-					project.aliases.some((alias) => alias.toLowerCase() === needle),
-			)
-			.slice(0, 11);
+		return this.registry.matchingProjects(reference);
 	}
 
 	registerProject(input: RegisterTaskProjectInput): TaskProject {
-		const now = new Date().toISOString();
-		const byRoot = [...this.projectRows.values()].find((project) => project.projectRoot === input.projectRoot);
-		const existing = input.existingId ? this.projectRows.get(input.existingId) : byRoot;
-		const name = input.name?.trim() || existing?.name || basename(input.projectRoot) || input.projectRoot;
-		const aliases = uniqueAliases(
-			[...(existing?.aliases ?? []), ...(existing && existing.name !== name ? [existing.name] : []), ...(input.aliases ?? [])],
-			name,
-		);
-		const project: TaskProject = {
-			id: existing?.id ?? randomUUID(),
-			name,
-			aliases,
-			projectRoot: input.projectRoot,
-			createdAt: existing?.createdAt ?? now,
-			updatedAt: now,
-		};
-		if (existing && existing.projectRoot !== project.projectRoot) {
-			for (const [taskId, scope] of this.scopes) {
-				if (scope.projectRoot === existing.projectRoot) this.scopes.set(taskId, { ...scope, projectRoot: project.projectRoot });
-			}
-			const view = this.views.get(existing.projectRoot);
-			if (view) {
-				this.views.delete(existing.projectRoot);
-				this.views.set(project.projectRoot, { ...view, projectRoot: project.projectRoot });
-			}
-		}
-		this.projectRows.set(project.id, project);
-		return project;
+		return this.registry.registerProject(input);
 	}
 }