@mndrk/agx 2.0.42 → 2.0.44

package/cloud-runtime/standalone/lib/db.ts

@@ -3,6 +3,7 @@ import { buildMarkdownWithFrontmatter } from "./orchestration/frontmatter";
 import { formatDependencyBlockedReason, isDependencyBlockedReason } from "@/lib/dependency-helpers";
 import { notifyTaskEvent } from "@/lib/notifications";
 import { randomUUID } from "crypto";
+import { vaultStore } from "./vault-store";
 
 // Task frontmatter fields (extracted from markdown)
 export type TaskStatus = "queued" | "in_progress" | "blocked" | "completed" | "failed";
@@ -797,8 +798,8 @@ export async function createTask(
   // Resolve project slug from project_id if not in frontmatter
   let projectSlug = typeof frontmatter.project === "string" ? frontmatter.project : undefined;
   if (!projectSlug && projectId) {
-    const { data: proj } = await db.from("projects").select("slug").eq("id", projectId).single();
-    if (proj?.slug) projectSlug = proj.slug;
+    const project = await getProjectWithRepos(projectId);
+    if (project?.slug) projectSlug = project.slug;
   }
 
   // Preserve provider/model/engine from frontmatter if provided
@@ -1184,7 +1185,7 @@ export async function getProjectWithRepos(
 ): Promise<ProjectWithRepos | null> {
   const db = createAdminDbClient();
   const isUuid = UUID_REGEX.test(projectIdOrSlug);
-  
+
   let projectQuery = db.from("projects").select("*");
   if (isUuid) {
     projectQuery = projectQuery.eq("id", projectIdOrSlug);
@@ -1273,15 +1274,14 @@ export async function updateProject(
 ): Promise<ProjectWithRepos | null> {
   const db = getDbClient(dbClient);
   const isUuid = UUID_REGEX.test(projectIdOrSlug);
-  
-  // First, get the actual project ID if we're using a slug
+
   let projectId = projectIdOrSlug;
   if (!isUuid) {
     const project = await getProjectBySlug(projectIdOrSlug, userId);
     if (!project) return null;
     projectId = project.id;
   }
-  
+
   const updatePayload: Record<string, unknown> = {};
 
   if (typeof updates.name !== "undefined") {
@@ -1385,6 +1385,7 @@ export async function deleteProject(
     .delete()
     .eq("id", projectId)
     .eq("user_id", userId);
+
   if (error) throw error;
 }
 
@@ -1394,15 +1395,7 @@ export async function assignOrphanTasksToProject(
   dbClient?: any
 ): Promise<{ updatedCount: number; taskIds: string[] }> {
   const db = getDbClient(dbClient);
-
-  const { data: project, error: projectError } = await db
-    .from("projects")
-    .select("id, slug")
-    .eq("id", projectId)
-    .eq("user_id", userId)
-    .maybeSingle();
-
-  if (projectError) throw projectError;
+  const project = await getProjectWithRepos(projectId, userId);
   if (!project) {
     throw new Error("Project not found");
   }
@@ -1429,11 +1422,11 @@ export async function assignOrphanTasksToProject(
 
   const { error: updateError } = await db
     .from("tasks")
-    .update({
-      project: project.slug,
-      project_id: project.id,
-      updated_at: new Date().toISOString(),
-    })
+      .update({
+        project: project.slug,
+        project_id: project.id,
+        updated_at: new Date().toISOString(),
+      })
     .eq("user_id", userId)
     .is("project_id", null)
     .in("id", orphanTaskIds);
@@ -2027,6 +2020,9 @@ export async function getLearnings(
   scopeId?: string,
   userId?: string
 ): Promise<Learning[]> {
+  if (scope !== "task") {
+    return vaultStore.getLearnings(scope, scopeId);
+  }
   const db = createAdminDbClient();
 
   let query = db
@@ -2049,6 +2045,9 @@ export async function addLearning(
   scopeId?: string,
   userId?: string
 ): Promise<Learning> {
+  if (scope !== "task") {
+    return vaultStore.addLearning(scope, content, scopeId);
+  }
   const db = createAdminDbClient();
 
   const { data, error } = await db
@@ -2062,6 +2061,15 @@ export async function addLearning(
 }
 
 export async function deleteLearning(id: string, userId?: string): Promise<void> {
+  if (id === "global-playbook") {
+    vaultStore.deleteLearning(id, "global");
+    return;
+  }
+  const project = await getProjectWithRepos(id, userId);
+  if (project) {
+    vaultStore.deleteLearning(id, "project", project.id);
+    return;
+  }
   const db = createAdminDbClient();
   let query = db.from("learnings").delete().eq("id", id);
   if (userId) query = query.eq("user_id", userId);
@@ -2569,20 +2577,8 @@ export async function getProjectMemory(
   projectId: string,
   producer?: "human" | "system"
 ): Promise<ProjectMemory[]> {
-  const db = createAdminDbClient();
-  let query = db
-    .from("project_memory")
-    .select("*")
-    .eq("project_id", projectId)
-    .order("created_at", { ascending: false });
-  if (producer) query = query.eq("producer", producer);
-  const { data, error } = await query;
-
-  if (error) {
-    if (isMissingRelationError(error, "project_memory")) return [];
-    throw error;
-  }
-  return data || [];
+  void producer;
+  return vaultStore.getProjectMemory(projectId);
 }
 
 export async function addProjectMemory(
@@ -2591,21 +2587,11 @@ export async function addProjectMemory(
   source?: string,
   producer: "human" | "system" = "human"
 ): Promise<ProjectMemory> {
-  const db = createAdminDbClient();
-  const { data, error } = await db
-    .from("project_memory")
-    .insert({ project_id: projectId, content, source: source ?? null, producer })
-    .select()
-    .single();
-
-  if (error) throw error;
-  return data;
+  return vaultStore.addProjectMemory(projectId, content, source, producer);
 }
 
 export async function deleteProjectMemory(memoryId: string): Promise<void> {
-  const db = createAdminDbClient();
-  const { error } = await db.from("project_memory").delete().eq("id", memoryId);
-  if (error) throw error;
+  vaultStore.deleteProjectMemory(memoryId);
 }
 
 // ============ PROJECT THREADS ============

package/cloud-runtime/standalone/lib/knowledge-notes.ts

@@ -1,251 +1,15 @@
-import { randomUUID } from "crypto";
-import { getSQLiteDb } from "./sqlite-query-adapter";
-import { listKnowledgeEntries, type KnowledgeScope, type KnowledgeSourceType } from "./knowledge-store";
+import { vaultStore, type VaultKnowledgeNote, type VaultKnowledgeNoteInput, type VaultKnowledgeScope } from "./vault-store";
 
-export type KnowledgeNoteScope = KnowledgeScope;
+export type KnowledgeNoteScope = VaultKnowledgeScope;
 
-export interface KnowledgeNote {
-  id: string;
-  scope: KnowledgeNoteScope;
-  subjectId: string;
-  content: string;
-  changeSummary: string | null;
-  sourceType: KnowledgeSourceType;
-  sourceId: string;
-  metadata: Record<string, unknown>;
-  version: number;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface UpsertKnowledgeNoteInput {
-  scope: KnowledgeNoteScope;
-  subjectId: string;
-  content: string;
-  changeSummary?: string | null;
-  sourceType: KnowledgeSourceType;
-  sourceId: string;
-  metadata?: Record<string, unknown>;
-}
+export interface KnowledgeNote extends VaultKnowledgeNote {}
 
-function parseJsonObject(raw: string | null): Record<string, unknown> {
-  if (!raw) return {};
-  try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : {};
-  } catch {
-    return {};
-  }
-}
-
-function normalizeContent(content: string): string {
-  return content
-    .replace(/\r\n/g, "\n")
-    .split("\n")
-    .map((line) => line.replace(/\s+$/g, ""))
-    .join("\n")
-    .trim();
-}
-
-function mapRow(row: {
-  id: string;
-  scope: KnowledgeNoteScope;
-  subject_id: string;
-  content: string;
-  change_summary: string | null;
-  source_type: KnowledgeSourceType;
-  source_id: string;
-  metadata: string | null;
-  version: number;
-  created_at: string;
-  updated_at: string;
-}): KnowledgeNote {
-  return {
-    id: row.id,
-    scope: row.scope,
-    subjectId: row.subject_id,
-    content: row.content,
-    changeSummary: row.change_summary ?? null,
-    sourceType: row.source_type,
-    sourceId: row.source_id,
-    metadata: parseJsonObject(row.metadata),
-    version: Number(row.version ?? 1),
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-  };
-}
-
-function getKnowledgeNoteRow(scope: KnowledgeNoteScope, subjectId: string) {
-  const db = getSQLiteDb();
-  return db
-    .prepare(
-      `SELECT id, scope, subject_id, content, change_summary, source_type, source_id,
-              metadata, version, created_at, updated_at
-       FROM knowledge_notes
-       WHERE scope = ? AND subject_id = ?
-       LIMIT 1`
-    )
-    .get(scope, subjectId) as {
-    id: string;
-    scope: KnowledgeNoteScope;
-    subject_id: string;
-    content: string;
-    change_summary: string | null;
-    source_type: KnowledgeSourceType;
-    source_id: string;
-    metadata: string | null;
-    version: number;
-    created_at: string;
-    updated_at: string;
-  } | undefined;
-}
-
-function listLegacySystemStatements(scope: KnowledgeNoteScope, subjectId: string): string[] {
-  const db = getSQLiteDb();
-  if (scope === "repo") {
-    const systemRepoRows = db
-      .prepare(
-        `SELECT content
-         FROM repo_knowledge
-         WHERE repo_id = ? AND producer = 'system'
-         ORDER BY created_at ASC`
-      )
-      .all(subjectId) as Array<{ content: string }>;
-    const entryBodies = listKnowledgeEntries({ scope: "repo", subjectId, limit: 100 })
-      .map((entry) => entry.body.trim());
-    return [...systemRepoRows.map((row) => row.content.trim()), ...entryBodies].filter(Boolean);
-  }
-
-  if (scope === "project") {
-    const systemProjectRows = db
-      .prepare(
-        `SELECT content
-         FROM project_memory
-         WHERE project_id = ? AND producer = 'system'
-         ORDER BY created_at ASC`
-      )
-      .all(subjectId) as Array<{ content: string }>;
-    const entryBodies = listKnowledgeEntries({ scope: "project", subjectId, limit: 100 })
-      .map((entry) => entry.body.trim());
-    return [...systemProjectRows.map((row) => row.content.trim()), ...entryBodies].filter(Boolean);
-  }
-
-  const agentRows = db
-    .prepare(
-      `SELECT content
-       FROM agent_memory
-       WHERE agent_id = ?
-       ORDER BY created_at ASC
-       LIMIT 100`
-    )
-    .all(subjectId) as Array<{ content: string }>;
-  const entryBodies = listKnowledgeEntries({ scope: "agent", subjectId, limit: 100 })
-    .map((entry) => entry.body.trim());
-  return [...agentRows.map((row) => row.content.trim()), ...entryBodies].filter(Boolean);
-}
-
-function synthesizeLegacyNoteContent(scope: KnowledgeNoteScope, subjectId: string): string {
-  const unique = Array.from(new Set(listLegacySystemStatements(scope, subjectId)));
-  if (unique.length === 0) return "";
-  return unique.map((line) => `- ${line.replace(/^\-\s*/, "")}`).join("\n");
-}
-
-function ensureKnowledgeNote(scope: KnowledgeNoteScope, subjectId: string): KnowledgeNote | null {
-  const existing = getKnowledgeNoteRow(scope, subjectId);
-  if (existing) return mapRow(existing);
-
-  const synthesized = synthesizeLegacyNoteContent(scope, subjectId);
-  if (!synthesized) return null;
-
-  const db = getSQLiteDb();
-  const now = new Date().toISOString();
-  const id = randomUUID();
-  db.prepare(
-    `INSERT INTO knowledge_notes (
-      id, scope, subject_id, content, change_summary, source_type, source_id, metadata, version, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, 'task_completion', 'legacy-synthesis', ?, 1, ?, ?)`
-  ).run(
-    id,
-    scope,
-    subjectId,
-    synthesized,
-    "Initial note synthesized from existing system knowledge",
-    JSON.stringify({ synthesized_from_legacy: true }),
-    now,
-    now,
-  );
-  db.prepare(
-    `INSERT INTO knowledge_note_versions (
-      id, note_id, version, content, change_summary, source_type, source_id, metadata, created_at
-    ) VALUES (?, ?, 1, ?, ?, 'task_completion', 'legacy-synthesis', ?, ?)`
-  ).run(
-    randomUUID(),
-    id,
-    synthesized,
-    "Initial note synthesized from existing system knowledge",
-    JSON.stringify({ synthesized_from_legacy: true }),
-    now,
-  );
-
-  const created = getKnowledgeNoteRow(scope, subjectId);
-  return created ? mapRow(created) : null;
-}
+export interface UpsertKnowledgeNoteInput extends VaultKnowledgeNoteInput {}
 
 export function getKnowledgeNote(scope: KnowledgeNoteScope, subjectId: string): KnowledgeNote | null {
-  const trimmedSubjectId = subjectId.trim();
-  if (!trimmedSubjectId) return null;
-  return ensureKnowledgeNote(scope, trimmedSubjectId);
+  return vaultStore.getKnowledgeNote(scope, subjectId);
 }
 
 export function upsertKnowledgeNote(input: UpsertKnowledgeNoteInput): { note: KnowledgeNote; changed: boolean } {
-  const db = getSQLiteDb();
-  const subjectId = input.subjectId.trim();
-  const sourceId = input.sourceId.trim();
-  const content = normalizeContent(input.content);
-  const changeSummary = input.changeSummary?.trim() || null;
-  if (!subjectId || !sourceId) {
-    throw new Error("subjectId and sourceId are required");
-  }
-
-  const existing = ensureKnowledgeNote(input.scope, subjectId);
-  if (existing && normalizeContent(existing.content) === content) {
-    return { note: existing, changed: false };
-  }
-
-  const now = new Date().toISOString();
-  const metadata = JSON.stringify(input.metadata ?? {});
-
-  if (!existing) {
-    const id = randomUUID();
-    db.prepare(
-      `INSERT INTO knowledge_notes (
-        id, scope, subject_id, content, change_summary, source_type, source_id, metadata, version, created_at, updated_at
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`
-    ).run(id, input.scope, subjectId, content, changeSummary, input.sourceType, sourceId, metadata, now, now);
-    db.prepare(
-      `INSERT INTO knowledge_note_versions (
-        id, note_id, version, content, change_summary, source_type, source_id, metadata, created_at
-      ) VALUES (?, ?, 1, ?, ?, ?, ?, ?, ?)`
-    ).run(randomUUID(), id, content, changeSummary, input.sourceType, sourceId, metadata, now);
-    const created = getKnowledgeNote(input.scope, subjectId);
-    if (!created) throw new Error("Failed to read created knowledge note");
-    return { note: created, changed: true };
-  }
-
-  const nextVersion = existing.version + 1;
-  db.prepare(
-    `UPDATE knowledge_notes
-     SET content = ?, change_summary = ?, source_type = ?, source_id = ?, metadata = ?, version = ?, updated_at = ?
-     WHERE id = ?`
-  ).run(content, changeSummary, input.sourceType, sourceId, metadata, nextVersion, now, existing.id);
-  db.prepare(
-    `INSERT INTO knowledge_note_versions (
-      id, note_id, version, content, change_summary, source_type, source_id, metadata, created_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  ).run(randomUUID(), existing.id, nextVersion, content, changeSummary, input.sourceType, sourceId, metadata, now);
-  const updated = getKnowledgeNote(input.scope, subjectId);
-  if (!updated) throw new Error("Failed to read updated knowledge note");
-  return { note: updated, changed: true };
+  return vaultStore.upsertKnowledgeNote(input);
 }

package/cloud-runtime/standalone/lib/knowledge-store.ts

@@ -1,9 +1,7 @@
-import { createHash, randomUUID } from "crypto";
-import { getSQLiteDb } from "./sqlite-query-adapter";
-import { transactionFn } from "./sqlite-compat";
+import { vaultStore, type VaultKnowledgeDraft, type VaultKnowledgeEntry, type VaultKnowledgeEvidence } from "./vault-store";
 
-export type KnowledgeScope = "agent" | "repo" | "project";
-export type KnowledgeSourceType = "reflection" | "thread_transition" | "task_completion";
+export type KnowledgeScope = "global" | "agent" | "repo" | "project";
+export type KnowledgeSourceType = "reflection" | "thread_transition" | "task_completion" | "manual";
 export type KnowledgeKind =
   | "outcome"
   | "decision"
@@ -14,221 +12,20 @@ export type KnowledgeKind =
   | "convention"
   | "lesson";
 
-export interface KnowledgeEvidence {
-  id?: string;
-  note: string;
-}
-
-export interface KnowledgeEntry {
-  id: string;
-  scope: KnowledgeScope;
-  subjectId: string;
-  sourceType: KnowledgeSourceType;
-  sourceId: string;
-  kind: KnowledgeKind;
-  title: string;
-  body: string;
-  confidence: number | null;
-  durability: number | null;
-  tags: string[];
-  evidence: KnowledgeEvidence[];
-  metadata: Record<string, unknown>;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface KnowledgeDraft {
-  scope: KnowledgeScope;
-  subjectId: string;
-  sourceType: KnowledgeSourceType;
-  sourceId: string;
-  kind: KnowledgeKind;
-  title: string;
-  body: string;
-  confidence?: number | null;
-  durability?: number | null;
-  tags?: string[];
-  evidence?: KnowledgeEvidence[];
-  metadata?: Record<string, unknown>;
-}
-
-function clampUnitNumber(value: unknown): number | null {
-  if (typeof value !== "number" || !Number.isFinite(value)) return null;
-  return Math.max(0, Math.min(1, value));
-}
-
-function parseJsonArray<T>(raw: string | null): T[] {
-  if (!raw) return [];
-  try {
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? (parsed as T[]) : [];
-  } catch {
-    return [];
-  }
-}
+export interface KnowledgeEvidence extends VaultKnowledgeEvidence {}
 
-function parseJsonObject(raw: string | null): Record<string, unknown> {
-  if (!raw) return {};
-  try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? (parsed as Record<string, unknown>)
-      : {};
-  } catch {
-    return {};
-  }
-}
-
-function normalizeTags(tags?: string[]): string[] {
-  const seen = new Set<string>();
-  const result: string[] = [];
-  for (const tag of tags ?? []) {
-    const trimmed = String(tag ?? "").trim().toLowerCase();
-    if (!trimmed || seen.has(trimmed)) continue;
-    seen.add(trimmed);
-    result.push(trimmed);
-  }
-  return result;
-}
+export interface KnowledgeEntry extends VaultKnowledgeEntry {}
 
-function normalizeEvidence(evidence?: KnowledgeEvidence[]): KnowledgeEvidence[] {
-  const result: KnowledgeEvidence[] = [];
-  for (const item of evidence ?? []) {
-    const note = String(item?.note ?? "").trim();
-    const id = typeof item?.id === "string" ? item.id.trim() : "";
-    if (!note) continue;
-    result.push(id ? { id, note } : { note });
-  }
-  return result;
-}
-
-function mapRow(row: {
-  id: string;
-  scope: KnowledgeScope;
-  subject_id: string;
-  source_type: KnowledgeSourceType;
-  source_id: string;
-  kind: KnowledgeKind;
-  title: string;
-  body: string;
-  confidence: number | null;
-  durability: number | null;
-  tags: string | null;
-  evidence: string | null;
-  metadata: string | null;
-  created_at: string;
-  updated_at: string;
-}): KnowledgeEntry {
-  return {
-    id: row.id,
-    scope: row.scope,
-    subjectId: row.subject_id,
-    sourceType: row.source_type,
-    sourceId: row.source_id,
-    kind: row.kind,
-    title: row.title,
-    body: row.body,
-    confidence: clampUnitNumber(row.confidence),
-    durability: clampUnitNumber(row.durability),
-    tags: parseJsonArray<string>(row.tags),
-    evidence: parseJsonArray<KnowledgeEvidence>(row.evidence),
-    metadata: parseJsonObject(row.metadata),
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-  };
-}
+export interface KnowledgeDraft extends VaultKnowledgeDraft {}
 
 export function listKnowledgeEntries(input: {
   scope: KnowledgeScope;
   subjectId: string;
   limit?: number;
 }): KnowledgeEntry[] {
-  const db = getSQLiteDb();
-  const rows = db
-    .prepare(
-      `SELECT id, scope, subject_id, source_type, source_id, kind, title, body,
-              confidence, durability, tags, evidence, metadata, created_at, updated_at
-       FROM knowledge_entries
-       WHERE scope = ? AND subject_id = ?
-       ORDER BY updated_at DESC, created_at DESC
-       LIMIT ?`
-    )
-    .all(input.scope, input.subjectId, input.limit ?? 50) as Array<{
-    id: string;
-    scope: KnowledgeScope;
-    subject_id: string;
-    source_type: KnowledgeSourceType;
-    source_id: string;
-    kind: KnowledgeKind;
-    title: string;
-    body: string;
-    confidence: number | null;
-    durability: number | null;
-    tags: string | null;
-    evidence: string | null;
-    metadata: string | null;
-    created_at: string;
-    updated_at: string;
-  }>;
-  return rows.map(mapRow);
+  return vaultStore.listKnowledgeEntries(input);
 }
 
 export function storeKnowledgeEntries(drafts: KnowledgeDraft[]): number {
-  if (drafts.length === 0) return 0;
-
-  const db = getSQLiteDb();
-  const now = new Date().toISOString();
-  const existingStmt = db.prepare(
-    `SELECT id
-     FROM knowledge_entries
-     WHERE scope = ? AND subject_id = ? AND content_hash = ?
-     LIMIT 1`
-  );
-  const insertStmt = db.prepare(
-    `INSERT INTO knowledge_entries (
-      id, scope, subject_id, source_type, source_id, kind, title, body,
-      confidence, durability, tags, evidence, metadata, content_hash, created_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-  );
-
-  let inserted = 0;
-  const tx = transactionFn(db, (entries: KnowledgeDraft[]) => {
-    for (const draft of entries) {
-      const subjectId = draft.subjectId.trim();
-      const title = draft.title.trim();
-      const body = draft.body.trim();
-      const sourceId = draft.sourceId.trim();
-      if (!subjectId || !title || !body || !sourceId) continue;
-
-      const contentHash = createHash("sha256")
-        .update(`${draft.scope}\n${subjectId}\n${body}`)
-        .digest("hex");
-
-      const existing = existingStmt.get(draft.scope, subjectId, contentHash) as { id: string } | undefined;
-      if (existing) continue;
-
-      insertStmt.run(
-        randomUUID(),
-        draft.scope,
-        subjectId,
-        draft.sourceType,
-        sourceId,
-        draft.kind,
-        title,
-        body,
-        clampUnitNumber(draft.confidence),
-        clampUnitNumber(draft.durability),
-        JSON.stringify(normalizeTags(draft.tags)),
-        JSON.stringify(normalizeEvidence(draft.evidence)),
-        JSON.stringify(draft.metadata ?? {}),
-        contentHash,
-        now,
-        now,
-      );
-      inserted += 1;
-    }
-  });
-
-  tx(drafts);
-  return inserted;
+  return vaultStore.storeKnowledgeEntries(drafts);
 }