zam-core 0.5.2 → 0.6.0

package/dist/index.js

@@ -616,6 +616,24 @@ CREATE TABLE IF NOT EXISTS session_syntheses (
   PRIMARY KEY (session_id, token_id)
 );
 
+-- Sources: textbook files, web links, or scan paths
+CREATE TABLE IF NOT EXISTS sources (
+  id          TEXT PRIMARY KEY,
+  type        TEXT NOT NULL CHECK (type IN ('file', 'web', 'scan')),
+  uri         TEXT NOT NULL UNIQUE,
+  content     TEXT,
+  created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+-- Token sources: mapping between tokens and their sources
+CREATE TABLE IF NOT EXISTS token_sources (
+  token_id    TEXT NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+  source_id   TEXT NOT NULL REFERENCES sources(id) ON DELETE CASCADE,
+  excerpt     TEXT NOT NULL DEFAULT '',
+  page_number TEXT,
+  PRIMARY KEY (token_id, source_id)
+);
+
 -- User configuration
 CREATE TABLE IF NOT EXISTS user_config (
   key         TEXT PRIMARY KEY,
@@ -943,6 +961,24 @@ async function runMigrations(db) {
       PRIMARY KEY (session_id, token_id)
     )
   `);
+  await db.exec(`
+    CREATE TABLE IF NOT EXISTS sources (
+      id          TEXT PRIMARY KEY,
+      type        TEXT NOT NULL CHECK (type IN ('file', 'web', 'scan')),
+      uri         TEXT NOT NULL UNIQUE,
+      content     TEXT,
+      created_at  TEXT NOT NULL DEFAULT (datetime('now'))
+    )
+  `);
+  await db.exec(`
+    CREATE TABLE IF NOT EXISTS token_sources (
+      token_id    TEXT NOT NULL REFERENCES tokens(id) ON DELETE CASCADE,
+      source_id   TEXT NOT NULL REFERENCES sources(id) ON DELETE CASCADE,
+      excerpt     TEXT NOT NULL DEFAULT '',
+      page_number TEXT,
+      PRIMARY KEY (token_id, source_id)
+    )
+  `);
 }
 
 // src/kernel/db/snapshot.ts
@@ -1646,6 +1682,415 @@ async function listTokens(db, options) {
     "SELECT * FROM tokens WHERE deprecated_at IS NULL ORDER BY bloom_level, domain, slug"
   ).all();
 }
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/(^-|-$)/g, "");
+}
+async function generateTokenSlug(db, domain, concept, question) {
+  const baseText = question && question.trim().length > 0 ? question : concept;
+  const cleanDomain = slugify(domain || "");
+  const cleanBase = slugify(baseText);
+  let baseSlug = cleanDomain ? `${cleanDomain}-${cleanBase}` : cleanBase;
+  if (baseSlug.length > 60) {
+    baseSlug = baseSlug.slice(0, 60).replace(/-$/, "");
+  }
+  if (!baseSlug) {
+    baseSlug = "token";
+  }
+  let slug = baseSlug;
+  let counter = 1;
+  while (true) {
+    const existing = await db.prepare("SELECT id FROM tokens WHERE slug = ?").get(slug);
+    if (!existing) {
+      return slug;
+    }
+    const suffix = `-${counter}`;
+    slug = baseSlug.slice(0, 60 - suffix.length).replace(/-$/, "") + suffix;
+    counter++;
+  }
+}
+async function listPersonalCards(db, userId, options) {
+  let sql = `
+    SELECT 
+      t.id AS tokenId,
+      t.slug,
+      t.concept,
+      t.domain,
+      t.bloom_level AS bloomLevel,
+      t.context,
+      t.symbiosis_mode AS symbiosisMode,
+      t.source_link AS sourceLink,
+      t.question,
+      t.created_at AS createdAt,
+      t.updated_at AS updatedAt,
+      c.id AS cardId,
+      c.state,
+      c.due_at AS dueAt,
+      c.stability,
+      c.difficulty,
+      c.reps,
+      c.lapses,
+      c.elapsed_days AS elapsedDays,
+      c.scheduled_days AS scheduledDays,
+      c.blocked
+    FROM tokens t
+    INNER JOIN cards c ON c.token_id = t.id AND c.user_id = ?
+    WHERE t.deprecated_at IS NULL
+  `;
+  const values = [userId];
+  if (options?.domain) {
+    sql += " AND t.domain = ?";
+    values.push(options.domain);
+  }
+  if (options?.query) {
+    const terms = options.query.toLowerCase().split(/\s+/).filter(Boolean);
+    for (const term of terms) {
+      sql += ` AND (lower(t.slug) LIKE ? OR lower(t.concept) LIKE ? OR lower(t.domain) LIKE ? OR lower(t.question) LIKE ?)`;
+      const pattern = `%${term}%`;
+      values.push(pattern, pattern, pattern, pattern);
+    }
+  }
+  sql += " ORDER BY t.created_at DESC";
+  const rows = await db.prepare(sql).all(...values);
+  return rows;
+}
+async function importCurriculumCards(db, userId, cards) {
+  let createdCount = 0;
+  let ensuredCount = 0;
+  await db.transaction(async (tx) => {
+    for (const card of cards) {
+      const bloom = card.bloom_level !== void 0 ? card.bloom_level : 1;
+      if (bloom < 1 || bloom > 5) {
+        throw new Error(`bloom_level must be between 1 and 5, got ${bloom}`);
+      }
+      let symbiosisMode = null;
+      if (card.symbiosis_mode) {
+        if (!["shadowing", "copilot", "autonomy", "none"].includes(
+          card.symbiosis_mode
+        )) {
+          throw new Error(`Invalid symbiosis_mode: ${card.symbiosis_mode}`);
+        }
+        symbiosisMode = card.symbiosis_mode === "none" ? null : card.symbiosis_mode;
+      }
+      const baseText = card.question && card.question.trim().length > 0 ? card.question : card.concept;
+      const cleanDomain = slugify(card.domain || "");
+      const cleanBase = slugify(baseText);
+      let baseSlug = cleanDomain ? `${cleanDomain}-${cleanBase}` : cleanBase;
+      if (baseSlug.length > 60) {
+        baseSlug = baseSlug.slice(0, 60).replace(/-$/, "");
+      }
+      if (!baseSlug) {
+        baseSlug = "token";
+      }
+      let token = await getTokenBySlug(tx, baseSlug);
+      if (!token) {
+        const finalSlug = await generateTokenSlug(
+          tx,
+          card.domain,
+          card.concept,
+          card.question
+        );
+        token = await createToken(tx, {
+          slug: finalSlug,
+          concept: card.concept,
+          domain: card.domain,
+          bloom_level: bloom,
+          context: card.context || "",
+          symbiosis_mode: symbiosisMode,
+          source_link: card.source_link || null,
+          question: card.question || null
+        });
+        createdCount++;
+      }
+      const existingCard = await getCard(tx, token.id, userId);
+      if (!existingCard) {
+        await ensureCard(tx, token.id, userId);
+        ensuredCount++;
+      }
+    }
+  });
+  return { createdCount, ensuredCount };
+}
+async function confirmCardSplit(db, userId, originalSlug, action, originalQuestion, originalConcept, proposals) {
+  if (action !== "block" && action !== "remove") {
+    throw new Error(`Invalid split action: ${action}`);
+  }
+  if (proposals.length < 2 || proposals.length > 4) {
+    throw new Error("A card split requires between 2 and 4 proposals");
+  }
+  const originalToken = await getTokenBySlug(db, originalSlug);
+  if (!originalToken) {
+    throw new Error(`Original token not found: ${originalSlug}`);
+  }
+  let createdCount = 0;
+  let ensuredCount = 0;
+  await db.transaction(async (tx) => {
+    const originalCard = await getCard(tx, originalToken.id, userId);
+    if (!originalCard) {
+      throw new Error(
+        `Card not found for token ${originalSlug} and user ${userId}`
+      );
+    }
+    const proposalTokens = [];
+    for (const card of proposals) {
+      const bloom = card.bloom_level !== void 0 ? card.bloom_level : 1;
+      if (bloom < 1 || bloom > 5) {
+        throw new Error(`bloom_level must be between 1 and 5, got ${bloom}`);
+      }
+      let symbiosisMode = null;
+      if (card.symbiosis_mode) {
+        if (!["shadowing", "copilot", "autonomy", "none"].includes(
+          card.symbiosis_mode
+        )) {
+          throw new Error(`Invalid symbiosis_mode: ${card.symbiosis_mode}`);
+        }
+        symbiosisMode = card.symbiosis_mode === "none" ? null : card.symbiosis_mode;
+      }
+      const baseText = card.question && card.question.trim().length > 0 ? card.question : card.concept;
+      const cleanDomain = slugify(card.domain || "");
+      const cleanBase = slugify(baseText);
+      let baseSlug = cleanDomain ? `${cleanDomain}-${cleanBase}` : cleanBase;
+      if (baseSlug.length > 60) {
+        baseSlug = baseSlug.slice(0, 60).replace(/-$/, "");
+      }
+      if (!baseSlug) {
+        baseSlug = "token";
+      }
+      let token = await getTokenBySlug(tx, baseSlug);
+      if (!token) {
+        const finalSlug = await generateTokenSlug(
+          tx,
+          card.domain,
+          card.concept,
+          card.question
+        );
+        token = await createToken(tx, {
+          slug: finalSlug,
+          concept: card.concept,
+          domain: card.domain,
+          bloom_level: bloom,
+          context: card.context || "",
+          symbiosis_mode: symbiosisMode,
+          source_link: card.source_link || originalToken.source_link || null,
+          question: card.question || null
+        });
+        createdCount++;
+      }
+      if (token.id === originalToken.id) {
+        throw new Error("A token cannot be a prerequisite of itself");
+      }
+      await assertPrerequisiteDoesNotCreateCycle(
+        tx,
+        originalToken.id,
+        token.id
+      );
+      proposalTokens.push(token);
+      const existingCard = await getCard(tx, token.id, userId);
+      if (!existingCard) {
+        await ensureCard(tx, token.id, userId);
+        ensuredCount++;
+      }
+    }
+    if (action === "block") {
+      await tx.prepare(
+        "UPDATE tokens SET question = ?, concept = ?, updated_at = ? WHERE id = ?"
+      ).run(
+        originalQuestion || null,
+        originalConcept,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        originalToken.id
+      );
+      for (const propToken of proposalTokens) {
+        await tx.prepare(
+          "INSERT OR IGNORE INTO prerequisites (token_id, requires_id) VALUES (?, ?)"
+        ).run(originalToken.id, propToken.id);
+      }
+      await tx.prepare(
+        "UPDATE cards SET blocked = 1 WHERE token_id = ? AND user_id = ?"
+      ).run(originalToken.id, userId);
+      for (const propToken of proposalTokens) {
+        const card = await ensureCard(tx, propToken.id, userId);
+        if (card.blocked === 1) {
+          const prereqOfPrereq = await tx.prepare(
+            "SELECT COUNT(*) as n FROM prerequisites WHERE token_id = ?"
+          ).get(propToken.id);
+          if (prereqOfPrereq.n === 0) {
+            const now = (/* @__PURE__ */ new Date()).toISOString();
+            await tx.prepare("UPDATE cards SET blocked = 0, due_at = ? WHERE id = ?").run(now, card.id);
+          }
+        }
+      }
+    } else if (action === "remove") {
+      await deleteCardForUser(tx, originalToken.id, userId);
+    }
+  });
+  return { createdCount, ensuredCount };
+}
+async function confirmFoundations(db, userId, originalSlug, proposals) {
+  const originalToken = await getTokenBySlug(db, originalSlug);
+  if (!originalToken) {
+    throw new Error(`Original token not found: ${originalSlug}`);
+  }
+  let createdCount = 0;
+  let linkedCount = 0;
+  await db.transaction(async (tx) => {
+    const originalCard = await getCard(tx, originalToken.id, userId);
+    if (!originalCard) {
+      throw new Error(
+        `Card not found for token ${originalSlug} and user ${userId}`
+      );
+    }
+    for (const card of proposals) {
+      let targetTokenId;
+      if (card.exists && card.slug) {
+        const existingToken = await getTokenBySlug(tx, card.slug);
+        if (!existingToken) {
+          throw new Error(`Prerequisite token not found by slug: ${card.slug}`);
+        }
+        targetTokenId = existingToken.id;
+        const existingCard = await getCard(tx, existingToken.id, userId);
+        if (!existingCard) {
+          await ensureCard(tx, existingToken.id, userId);
+        }
+        linkedCount++;
+      } else {
+        const bloom = card.bloom_level !== void 0 ? card.bloom_level : 1;
+        if (bloom < 1 || bloom > 5) {
+          throw new Error(`bloom_level must be between 1 and 5, got ${bloom}`);
+        }
+        let symbiosisMode = null;
+        if (card.symbiosis_mode) {
+          if (!["shadowing", "copilot", "autonomy", "none"].includes(
+            card.symbiosis_mode
+          )) {
+            throw new Error(`Invalid symbiosis_mode: ${card.symbiosis_mode}`);
+          }
+          symbiosisMode = card.symbiosis_mode === "none" ? null : card.symbiosis_mode;
+        }
+        const baseText = card.question && card.question.trim().length > 0 ? card.question : card.concept;
+        const cleanDomain = slugify(card.domain || "");
+        const cleanBase = slugify(baseText);
+        let baseSlug = cleanDomain ? `${cleanDomain}-${cleanBase}` : cleanBase;
+        if (baseSlug.length > 60) {
+          baseSlug = baseSlug.slice(0, 60).replace(/-$/, "");
+        }
+        if (!baseSlug) {
+          baseSlug = "token";
+        }
+        let token = await getTokenBySlug(tx, baseSlug);
+        if (!token) {
+          const finalSlug = await generateTokenSlug(
+            tx,
+            card.domain,
+            card.concept,
+            card.question
+          );
+          token = await createToken(tx, {
+            slug: finalSlug,
+            concept: card.concept,
+            domain: card.domain,
+            bloom_level: bloom,
+            context: card.context || "",
+            symbiosis_mode: symbiosisMode,
+            source_link: card.source_link || originalToken.source_link || null,
+            question: card.question || null
+          });
+          createdCount++;
+        }
+        targetTokenId = token.id;
+        const existingCard = await getCard(tx, token.id, userId);
+        if (!existingCard) {
+          await ensureCard(tx, token.id, userId);
+        }
+      }
+      if (targetTokenId === originalToken.id) {
+        throw new Error("A token cannot be a prerequisite of itself");
+      }
+      await assertPrerequisiteDoesNotCreateCycle(
+        tx,
+        originalToken.id,
+        targetTokenId
+      );
+      await tx.prepare(
+        "INSERT OR IGNORE INTO prerequisites (token_id, requires_id) VALUES (?, ?)"
+      ).run(originalToken.id, targetTokenId);
+    }
+  });
+  return { createdCount, linkedCount };
+}
+async function confirmSourceImport(db, userId, sourceId, proposals) {
+  let createdCount = 0;
+  let linkedCount = 0;
+  await db.transaction(async (tx) => {
+    const source = await tx.prepare("SELECT id FROM sources WHERE id = ?").get(sourceId);
+    if (!source) {
+      throw new Error(`Source not found: ${sourceId}`);
+    }
+    for (const card of proposals) {
+      const baseText = card.question && card.question.trim().length > 0 ? card.question : card.concept;
+      const cleanDomain = slugify(card.domain || "");
+      const cleanBase = slugify(baseText);
+      let baseSlug = cleanDomain ? `${cleanDomain}-${cleanBase}` : cleanBase;
+      if (baseSlug.length > 60) {
+        baseSlug = baseSlug.slice(0, 60).replace(/-$/, "");
+      }
+      if (!baseSlug) {
+        baseSlug = "token";
+      }
+      let token = await getTokenBySlug(tx, baseSlug);
+      if (!token) {
+        const finalSlug = await generateTokenSlug(
+          tx,
+          card.domain,
+          card.concept,
+          card.question
+        );
+        const bloom = card.bloom_level !== void 0 ? card.bloom_level : 1;
+        let symbiosisMode = null;
+        if (card.symbiosis_mode && card.symbiosis_mode !== "none") {
+          symbiosisMode = card.symbiosis_mode;
+        }
+        token = await createToken(tx, {
+          slug: finalSlug,
+          concept: card.concept,
+          domain: card.domain,
+          bloom_level: bloom,
+          context: card.excerpt || "",
+          symbiosis_mode: symbiosisMode,
+          question: card.question || null
+        });
+        createdCount++;
+      } else {
+        linkedCount++;
+      }
+      const existingCard = await getCard(tx, token.id, userId);
+      if (!existingCard) {
+        await ensureCard(tx, token.id, userId);
+      }
+      await tx.prepare(
+        `INSERT INTO token_sources (token_id, source_id, excerpt, page_number)
+           VALUES (?, ?, ?, ?)
+           ON CONFLICT(token_id, source_id) DO UPDATE SET
+             excerpt = excluded.excerpt,
+             page_number = excluded.page_number`
+      ).run(token.id, sourceId, card.excerpt || "", card.page_number || null);
+    }
+  });
+  return { createdCount, linkedCount };
+}
+async function assertPrerequisiteDoesNotCreateCycle(db, tokenId, prerequisiteId) {
+  const cycleCheck = await db.prepare(
+    `WITH RECURSIVE dependents(token_id) AS (
+         SELECT token_id FROM prerequisites WHERE requires_id = ?
+         UNION
+         SELECT p.token_id FROM prerequisites p
+         JOIN dependents d ON p.requires_id = d.token_id
+       )
+       SELECT COUNT(*) as n FROM dependents WHERE token_id = ?`
+  ).get(tokenId, prerequisiteId);
+  if (cycleCheck.n > 0) {
+    throw new Error("Cannot add prerequisite: would create a cycle");
+  }
+}
 
 // src/kernel/models/prerequisite.ts
 async function buildAncestorMap(db) {
@@ -4533,22 +4978,49 @@ function getConfiguredWorkspaces(path = defaultConfigPath()) {
 function saveConfiguredWorkspaces(workspaces, path = defaultConfigPath()) {
   const config = loadInstallConfig(path);
   config.workspaces = workspaces;
+  if (config.activeWorkspaceId && !workspaces.some((workspace) => workspace.id === config.activeWorkspaceId)) {
+    config.activeWorkspaceId = workspaces[0]?.id;
+  }
   saveInstallConfig(config, path);
 }
+function getActiveWorkspaceId(path = defaultConfigPath()) {
+  return loadInstallConfig(path).activeWorkspaceId;
+}
+function setActiveWorkspaceId(id, path = defaultConfigPath()) {
+  const config = loadInstallConfig(path);
+  if (id) {
+    config.activeWorkspaceId = id;
+  } else {
+    delete config.activeWorkspaceId;
+  }
+  saveInstallConfig(config, path);
+}
+function getActiveWorkspace(path = defaultConfigPath()) {
+  const config = loadInstallConfig(path);
+  const id = config.activeWorkspaceId;
+  return id ? config.workspaces?.find((workspace) => workspace.id === id) : void 0;
+}
 function upsertConfiguredWorkspace(workspace, path = defaultConfigPath()) {
-  const current = getConfiguredWorkspaces(path);
+  const config = loadInstallConfig(path);
+  const current = config.workspaces ?? [];
   const next = [
     ...current.filter((candidate) => candidate.id !== workspace.id),
     workspace
   ];
-  saveConfiguredWorkspaces(next, path);
+  config.workspaces = next;
+  saveInstallConfig(config, path);
   return next;
 }
 function removeConfiguredWorkspace(id, path = defaultConfigPath()) {
-  const next = getConfiguredWorkspaces(path).filter(
+  const config = loadInstallConfig(path);
+  const next = (config.workspaces ?? []).filter(
     (workspace) => workspace.id !== id
   );
-  saveConfiguredWorkspaces(next, path);
+  config.workspaces = next;
+  if (config.activeWorkspaceId === id) {
+    config.activeWorkspaceId = next[0]?.id;
+  }
+  saveInstallConfig(config, path);
   return next;
 }
 function detectSyncProvider(dir) {
@@ -4880,7 +5352,7 @@ function getSystemProfile() {
 import { existsSync as existsSync10 } from "fs";
 import { resolve as resolve2 } from "path";
 async function getRepoPaths(db) {
-  const personalSetting = await getSetting(db, "repo.personal") || await getSetting(db, "personal.workspace_dir");
+  const personalSetting = await getSetting(db, "repo.personal") || getActiveWorkspace()?.path;
   const teamSetting = await getSetting(db, "repo.team");
   const orgSetting = await getSetting(db, "repo.org");
   return {
@@ -5067,6 +5539,9 @@ export {
   clearReviewContextCache,
   clearTursoCredentials,
   compareVersions,
+  confirmCardSplit,
+  confirmFoundations,
+  confirmSourceImport,
   createAgentSkill,
   createFSRS,
   createGoal,
@@ -5099,9 +5574,12 @@ export {
   generatePowerShellHooks,
   generatePowerShellUnhooks,
   generatePrompt,
+  generateTokenSlug,
   generateZshHooks,
   generateZshUnhooks,
   getADOCredentials,
+  getActiveWorkspace,
+  getActiveWorkspaceId,
   getAgentSkill,
   getAllSettings,
   getAllSettingsDetailed,
@@ -5142,6 +5620,7 @@ export {
   getUiObserverDir,
   getUserStats,
   hasCommand,
+  importCurriculumCards,
   importSnapshot,
   injectShellHooks,
   installFastFlowLM,
@@ -5152,6 +5631,7 @@ export {
   isUiObservationReport,
   listAgentSkills,
   listGoals,
+  listPersonalCards,
   listProviderApiKeyRefs,
   listTokens,
   loadADOConfig,
@@ -5194,11 +5674,13 @@ export {
   saveMachineAiConfig,
   serializeGoal,
   setADOCredentials,
+  setActiveWorkspaceId,
   setInstallChannel,
   setInstallMode,
   setProviderApiKey,
   setSetting,
   setTursoCredentials,
+  slugify,
   startSession,
   syncObserverSidecarPolicy,
   t,