syntaur 0.8.0 → 0.12.0

package/dist/dashboard/server.js

@@ -16,6 +16,7 @@ __export(paths_exports, {
   expandHome: () => expandHome,
   playbooksDir: () => playbooksDir,
   projectTodosDir: () => projectTodosDir,
+  proofDir: () => proofDir,
   serversDir: () => serversDir,
   syntaurRoot: () => syntaurRoot,
   todoPlanDir: () => todoPlanDir,
@@ -57,6 +58,9 @@ function projectTodosDir(projectsDir, projectSlug) {
 function todoPlanDir(todosDir2, workspaceOrProject, todoId) {
   return resolve(todosDir2, "plans", workspaceOrProject, todoId);
 }
+function proofDir(assignmentDir) {
+  return resolve(assignmentDir, "proof");
+}
 var init_paths = __esm({
   "src/utils/paths.ts"() {
     "use strict";
@@ -2071,6 +2075,7 @@ function parseMemory(fileContent) {
     scope: getField(fm, "scope") ?? "",
     sourceAssignment: getField(fm, "sourceAssignment"),
     relatedAssignments: parseListField(fm, "relatedAssignments"),
+    tags: parseListField(fm, "tags"),
     created: getField(fm, "created") ?? "",
     updated: getField(fm, "updated") ?? "",
     body
@@ -3269,7 +3274,7 @@ var init_scanner = __esm({
 
 // src/dashboard/api.ts
 import { readdir as readdir6, readFile as readFile8, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve9, dirname as dirname2 } from "path";
+import { resolve as resolve9, dirname as dirname2, basename } from "path";
 async function listStandaloneRecords(assignmentsDir2) {
   if (!assignmentsDir2) return [];
   if (!await fileExists(assignmentsDir2)) return [];
@@ -4108,12 +4113,102 @@ async function listMemories(projectPath) {
       source: parsed.source,
       scope: parsed.scope,
       sourceAssignment: parsed.sourceAssignment,
+      relatedAssignments: parsed.relatedAssignments,
       updated: parsed.updated
     });
   }
   results.sort((left, right) => compareTimestamps(right.updated, left.updated));
   return results;
 }
+async function listAllMemories(projectsDir) {
+  const projectRecords = await listProjectRecords(projectsDir);
+  const all = [];
+  for (const record of projectRecords) {
+    const memories = await listMemories(record.projectPath);
+    for (const memory of memories) {
+      all.push({
+        ...memory,
+        projectSlug: basename(record.projectPath),
+        projectTitle: record.summary.title
+      });
+    }
+  }
+  all.sort((left, right) => compareTimestamps(right.updated, left.updated));
+  return all;
+}
+async function listAllResources(projectsDir) {
+  const projectRecords = await listProjectRecords(projectsDir);
+  const all = [];
+  for (const record of projectRecords) {
+    const resources = await listResources(record.projectPath);
+    for (const resource of resources) {
+      all.push({
+        ...resource,
+        projectSlug: basename(record.projectPath),
+        projectTitle: record.summary.title
+      });
+    }
+  }
+  all.sort((left, right) => compareTimestamps(right.updated, left.updated));
+  return all;
+}
+async function resolveProjectPath(projectsDir, projectSlug) {
+  const direct = resolve9(projectsDir, projectSlug);
+  if (await fileExists(resolve9(direct, "project.md"))) return direct;
+  const records = await listProjectRecords(projectsDir);
+  const match = records.find((r) => r.summary.slug === projectSlug);
+  return match ? match.projectPath : null;
+}
+async function getMemoryDetail(projectsDir, projectSlug, itemSlug) {
+  if (itemSlug.startsWith("_")) return null;
+  const projectRecords = await listProjectRecords(projectsDir);
+  const projectRecord = projectRecords.find(
+    (p) => basename(p.projectPath) === projectSlug || p.summary.slug === projectSlug
+  );
+  if (!projectRecord) return null;
+  const filePath = resolve9(projectRecord.projectPath, "memories", `${itemSlug}.md`);
+  if (!await fileExists(filePath)) return null;
+  const content = await readFile8(filePath, "utf-8");
+  const parsed = parseMemory(content);
+  return {
+    name: parsed.name,
+    slug: itemSlug,
+    source: parsed.source,
+    scope: parsed.scope,
+    sourceAssignment: parsed.sourceAssignment,
+    relatedAssignments: parsed.relatedAssignments,
+    updated: parsed.updated,
+    created: parsed.created,
+    body: parsed.body,
+    tags: parsed.tags,
+    projectSlug: basename(projectRecord.projectPath),
+    projectTitle: projectRecord.summary.title
+  };
+}
+async function getResourceDetail(projectsDir, projectSlug, itemSlug) {
+  if (itemSlug.startsWith("_")) return null;
+  const projectRecords = await listProjectRecords(projectsDir);
+  const projectRecord = projectRecords.find(
+    (p) => basename(p.projectPath) === projectSlug || p.summary.slug === projectSlug
+  );
+  if (!projectRecord) return null;
+  const filePath = resolve9(projectRecord.projectPath, "resources", `${itemSlug}.md`);
+  if (!await fileExists(filePath)) return null;
+  const content = await readFile8(filePath, "utf-8");
+  const parsed = parseResource(content);
+  return {
+    name: parsed.name,
+    slug: itemSlug,
+    category: parsed.category,
+    source: parsed.source,
+    relatedAssignments: parsed.relatedAssignments,
+    updated: parsed.updated,
+    created: parsed.created,
+    body: parsed.body,
+    projectSlug: basename(projectRecord.projectPath),
+    projectTitle: projectRecord.summary.title
+  };
+}
 async function loadDependencyGraph(projectPath, assignments) {
   const statusPath = resolve9(projectPath, "_status.md");
   if (await fileExists(statusPath)) {
@@ -4449,6 +4544,10 @@ function getDocumentPath(projectsDir, documentType, projectSlug, assignmentSlug)
       return assignmentSlug ? resolve9(projectsDir, projectSlug, "assignments", assignmentSlug, "handoff.md") : null;
     case "decision-record":
       return assignmentSlug ? resolve9(projectsDir, projectSlug, "assignments", assignmentSlug, "decision-record.md") : null;
+    case "memory":
+      return assignmentSlug ? resolve9(projectsDir, projectSlug, "memories", `${assignmentSlug}.md`) : null;
+    case "resource":
+      return assignmentSlug ? resolve9(projectsDir, projectSlug, "resources", `${assignmentSlug}.md`) : null;
     default:
       return null;
   }
@@ -4469,6 +4568,10 @@ function getEditableDocumentTitle(documentType, projectSlug, assignmentSlug) {
       return `Append Decision: ${assignmentSlug || "assignment"}`;
     case "playbook":
       return `Edit Playbook: ${projectSlug}`;
+    case "memory":
+      return `Edit Memory: ${assignmentSlug || "memory"}`;
+    case "resource":
+      return `Edit Resource: ${assignmentSlug || "resource"}`;
     default:
       return projectSlug;
   }
@@ -4910,6 +5013,40 @@ var init_decision_record = __esm({
 });
 
 // src/templates/index-stubs.ts
+function renderMemoryStub(params2) {
+  return `---
+type: memory
+name: ${escapeYamlString(params2.name)}
+source: claude
+sourceAssignment: null
+relatedAssignments: []
+scope: project
+created: "${params2.timestamp}"
+updated: "${params2.timestamp}"
+tags: []
+---
+
+# ${params2.name}
+
+`;
+}
+function renderResourceStub(params2) {
+  return `---
+type: resource
+name: ${escapeYamlString(params2.name)}
+source: claude
+category: documentation
+sourceUrl: null
+sourceAssignment: null
+relatedAssignments: []
+created: "${params2.timestamp}"
+updated: "${params2.timestamp}"
+---
+
+# ${params2.name}
+
+`;
+}
 function renderIndexAssignments(params2) {
   return `---
 project: ${params2.slug}
@@ -5022,6 +5159,7 @@ total: 0
 var init_index_stubs = __esm({
   "src/templates/index-stubs.ts"() {
     "use strict";
+    init_yaml();
   }
 });
 
@@ -6255,8 +6393,8 @@ init_timestamp();
 init_fs();
 init_parser();
 import { Router } from "express";
-import { resolve as resolve12 } from "path";
-import { rm, readFile as readFile10 } from "fs/promises";
+import { resolve as resolve12, basename as basename2 } from "path";
+import { rm, readFile as readFile10, open as fsOpen } from "fs/promises";
 
 // src/dashboard/acceptance-criteria.ts
 function splitFrontmatter(content) {
@@ -6528,6 +6666,210 @@ function createWriteRouter(projectsDir, assignmentsDir2) {
     }
     res.json(document);
   });
+  router.get("/api/projects/:slug/memories/:itemSlug/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const itemSlug = getParam(req.params.itemSlug);
+    if (!isValidSlug(itemSlug)) {
+      res.status(400).json({ error: "Invalid memory slug." });
+      return;
+    }
+    const projectDir = await resolveProjectPath(projectsDir, slug);
+    if (!projectDir) {
+      res.status(404).json({ error: `Project "${slug}" not found` });
+      return;
+    }
+    const document = await getEditableDocument(projectsDir, "memory", basename2(projectDir), itemSlug);
+    if (!document) {
+      res.status(404).json({ error: "Memory not found" });
+      return;
+    }
+    res.json(document);
+  });
+  router.get("/api/projects/:slug/resources/:itemSlug/edit", async (req, res) => {
+    const slug = getParam(req.params.slug);
+    const itemSlug = getParam(req.params.itemSlug);
+    if (!isValidSlug(itemSlug)) {
+      res.status(400).json({ error: "Invalid resource slug." });
+      return;
+    }
+    const projectDir = await resolveProjectPath(projectsDir, slug);
+    if (!projectDir) {
+      res.status(404).json({ error: `Project "${slug}" not found` });
+      return;
+    }
+    const document = await getEditableDocument(projectsDir, "resource", basename2(projectDir), itemSlug);
+    if (!document) {
+      res.status(404).json({ error: "Resource not found" });
+      return;
+    }
+    res.json(document);
+  });
+  function itemFolder(kind) {
+    return kind === "memory" ? "memories" : "resources";
+  }
+  function renderItemStub(kind, params2) {
+    return kind === "memory" ? renderMemoryStub(params2) : renderResourceStub(params2);
+  }
+  function replaceStubBody(stub, body) {
+    const match = stub.match(/^(---\r?\n[\s\S]*?\r?\n---\r?\n)/);
+    if (!match) return stub;
+    return `${match[1]}
+${body.startsWith("\n") ? body.slice(1) : body}${body.endsWith("\n") ? "" : "\n"}`;
+  }
+  function extractFrontmatterBlock(content) {
+    const match = content.match(/^(---\r?\n[\s\S]*?\r?\n---\r?\n)/);
+    return match ? match[1] : null;
+  }
+  function parseItem(kind, content) {
+    return kind === "memory" ? parseMemory(content) : parseResource(content);
+  }
+  async function getItemDetail(kind, projectSlug, itemSlug) {
+    return kind === "memory" ? await getMemoryDetail(projectsDir, projectSlug, itemSlug) : await getResourceDetail(projectsDir, projectSlug, itemSlug);
+  }
+  async function resolveProjectDir(projectSlug) {
+    return resolveProjectPath(projectsDir, projectSlug);
+  }
+  function rejectBadItemSlug(itemSlug, kind, res) {
+    if (isValidSlug(itemSlug)) return false;
+    res.status(400).json({
+      error: `Invalid ${kind} slug "${itemSlug}". Slugs must be lowercase letters, numbers, and hyphens only.`
+    });
+    return true;
+  }
+  for (const kind of ["memory", "resource"]) {
+    const folder = itemFolder(kind);
+    router.get(`/api/projects/:slug/${folder}/:itemSlug`, async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const itemSlug = getParam(req.params.itemSlug);
+        if (rejectBadItemSlug(itemSlug, kind, res)) return;
+        const detail = await getItemDetail(kind, projectSlug, itemSlug);
+        if (!detail) {
+          res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
+          return;
+        }
+        res.json(detail);
+      } catch (error) {
+        console.error(`Error fetching ${kind} detail:`, error);
+        res.status(500).json({ error: `Failed to load ${kind}: ${error.message}` });
+      }
+    });
+    router.post(`/api/projects/:slug/${folder}`, async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const projectDir = await resolveProjectDir(projectSlug);
+        if (!projectDir) {
+          res.status(404).json({ error: `Project "${projectSlug}" not found` });
+          return;
+        }
+        const body = req.body ?? {};
+        const name = typeof body.name === "string" ? body.name.trim() : "";
+        if (!name) {
+          res.status(400).json({ error: "Name is required." });
+          return;
+        }
+        const requestedSlug = typeof body.slug === "string" && body.slug.trim() ? body.slug.trim() : slugify(name);
+        if (!requestedSlug || !isValidSlug(requestedSlug)) {
+          res.status(400).json({
+            error: `Slug "${requestedSlug}" is invalid. Slugs must be lowercase letters, numbers, and hyphens only.`
+          });
+          return;
+        }
+        const folderPath = resolve12(projectDir, folder);
+        await ensureDir(folderPath);
+        const filePath = resolve12(folderPath, `${requestedSlug}.md`);
+        const timestamp = nowTimestamp();
+        let content = renderItemStub(kind, {
+          slug: requestedSlug,
+          name,
+          projectSlug: basename2(projectDir),
+          timestamp
+        });
+        const customBody = typeof body.body === "string" ? body.body : "";
+        if (customBody.trim()) {
+          content = replaceStubBody(content, customBody);
+        }
+        try {
+          const handle = await fsOpen(filePath, "wx");
+          try {
+            await handle.writeFile(content, "utf-8");
+          } finally {
+            await handle.close();
+          }
+        } catch (err) {
+          if (err.code === "EEXIST") {
+            res.status(409).json({
+              error: `${kind === "memory" ? "Memory" : "Resource"} with slug "${requestedSlug}" already exists in project "${basename2(projectDir)}".`
+            });
+            return;
+          }
+          throw err;
+        }
+        res.status(201).json({ slug: requestedSlug, projectSlug: basename2(projectDir), content });
+      } catch (error) {
+        console.error(`Error creating ${kind}:`, error);
+        res.status(500).json({ error: `Failed to create ${kind}: ${error.message}` });
+      }
+    });
+    router.patch(`/api/projects/:slug/${folder}/:itemSlug`, async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const itemSlug = getParam(req.params.itemSlug);
+        if (rejectBadItemSlug(itemSlug, kind, res)) return;
+        const projectDir = await resolveProjectDir(projectSlug);
+        if (!projectDir) {
+          res.status(404).json({ error: `Project "${projectSlug}" not found` });
+          return;
+        }
+        const filePath = resolve12(projectDir, folder, `${itemSlug}.md`);
+        if (!await fileExists(filePath)) {
+          res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
+          return;
+        }
+        const nextContentRaw = requireContent(req, res);
+        if (!nextContentRaw) return;
+        const currentContent = await readFile10(filePath, "utf-8");
+        const frontmatterBlock = extractFrontmatterBlock(currentContent);
+        if (!frontmatterBlock) {
+          res.status(500).json({ error: `${kind} file is malformed (no frontmatter)` });
+          return;
+        }
+        const next = parseItem(kind, nextContentRaw);
+        const nextBody = next.body.trimStart();
+        let merged = `${frontmatterBlock}
+${nextBody}${nextBody.endsWith("\n") ? "" : "\n"}`;
+        merged = setTopLevelField(merged, "updated", nowTimestamp());
+        await writeFileForce(filePath, merged);
+        const detail = await getItemDetail(kind, basename2(projectDir), itemSlug);
+        res.json({ [kind]: detail, content: merged });
+      } catch (error) {
+        console.error(`Error updating ${kind}:`, error);
+        res.status(500).json({ error: `Failed to update ${kind}: ${error.message}` });
+      }
+    });
+    router.delete(`/api/projects/:slug/${folder}/:itemSlug`, async (req, res) => {
+      try {
+        const projectSlug = getParam(req.params.slug);
+        const itemSlug = getParam(req.params.itemSlug);
+        if (rejectBadItemSlug(itemSlug, kind, res)) return;
+        const projectDir = await resolveProjectDir(projectSlug);
+        if (!projectDir) {
+          res.status(404).json({ error: `Project "${projectSlug}" not found` });
+          return;
+        }
+        const filePath = resolve12(projectDir, folder, `${itemSlug}.md`);
+        if (!await fileExists(filePath)) {
+          res.status(404).json({ error: `${kind === "memory" ? "Memory" : "Resource"} not found` });
+          return;
+        }
+        await rm(filePath);
+        res.status(204).end();
+      } catch (error) {
+        console.error(`Error deleting ${kind}:`, error);
+        res.status(500).json({ error: `Failed to delete ${kind}: ${error.message}` });
+      }
+    });
+  }
   router.post("/api/projects", async (req, res) => {
     try {
       const content = requireContent(req, res);
@@ -10699,6 +11041,24 @@ function createDashboardServer(options) {
   app.use("/api/servers", createServersRouter(serversDir2, projectsDir, assignmentsDir2));
   app.use("/api/agent-sessions", createAgentSessionsRouter(projectsDir, broadcast, assignmentsDir2));
   app.use("/api/playbooks", createPlaybooksRouter(playbooksDir2));
+  app.get("/api/memories", async (_req, res) => {
+    try {
+      const memories = await listAllMemories(projectsDir);
+      res.json({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), memories });
+    } catch (error) {
+      console.error("Error listing memories:", error);
+      res.status(500).json({ error: `Failed to load memories: ${error.message}` });
+    }
+  });
+  app.get("/api/resources", async (_req, res) => {
+    try {
+      const resources = await listAllResources(projectsDir);
+      res.json({ generatedAt: (/* @__PURE__ */ new Date()).toISOString(), resources });
+    } catch (error) {
+      console.error("Error listing resources:", error);
+      res.status(500).json({ error: `Failed to load resources: ${error.message}` });
+    }
+  });
   app.use("/api/todos", createTodosRouter(todosDir2, broadcast, projectsDir));
   app.use("/api/projects/:projectId/todos", createProjectTodosRouter(projectsDir, broadcast, todosDir2));
   app.use("/api/backup", createBackupRouter());