amalgm 0.1.245 → 0.1.246

package/runtime/scripts/amalgm-mcp/workspace/tree/inclusion.js

@@ -57,13 +57,7 @@ function isPrivateFile(name) {
 // enrolled as leaf nodes and are never followed by the scanner.
 function shouldEnroll(relativePath) {
   const parts = partsFor(relativePath);
-  if (
-    parts.length === 0
-    || parts.some((part) => (
-      EXCLUDED_DIRECTORIES.has(part)
-      || part.startsWith('.amalgm-tree-apply-')
-    ))
-  ) return false;
+  if (parts.length === 0 || parts.some((part) => EXCLUDED_DIRECTORIES.has(part))) return false;
   const name = parts.at(-1);
   if (EXCLUDED_FILES.has(name) || isPrivateFile(name)) return false;
   return !name.startsWith('.#') && !name.endsWith('~') && !/\.(?:swp|swo)$/i.test(name);

package/runtime/scripts/amalgm-mcp/workspace/tree/local-state.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const { AMALGM_DIR } = require('../../config');
 const { openLocalDb } = require('../../state/db');
+const { descendantsInclude } = require('./reducer');
 
 function invalid(message, statusCode = 400) {
   return Object.assign(new Error(message), { statusCode });
@@ -22,7 +23,6 @@ function rowToNode(row) {
     deviceId: row.device_id || null,
     inode: row.inode || null,
     trashedAt: row.trashed_at || null,
-    trashComponentId: row.trash_component_id || null,
     purgedAt: row.purged_at || null,
     missingAt: row.missing_at || null,
     createdAt: row.created_at,
@@ -53,24 +53,58 @@ function relativePathForNode(nodes, nodeId, memo = new Map()) {
   return relativePath;
 }
 
-function trashPath(workspaceId, nodeId, workspacePath = null) {
-  if (workspacePath) {
-    // Tree trash participates in the same rename-only WAL as the visible
-    // workspace. Keep it beside that workspace so arbitrary registered
-    // folders (including external volumes) never turn trash/restore into an
-    // impossible cross-device rename.
-    return path.join(
-      path.dirname(path.resolve(workspacePath)),
-      `.amalgm-tree-trash-${workspaceId}`,
-      nodeId,
-    );
-  }
-  // Compatibility for callers that only need the historical locator. New
-  // materialization plans always pass workspacePath and persist the exact
-  // same-filesystem location in their action.
+function trashPath(workspaceId, nodeId) {
   return path.join(AMALGM_DIR, 'trash', 'workspaces', workspaceId, nodeId);
 }
 
+function requireMissing(targetPath, message) {
+  try {
+    fs.lstatSync(targetPath);
+    throw invalid(message, 409);
+  } catch (error) {
+    if (error?.code !== 'ENOENT') throw error;
+  }
+}
+
+function materializeOperation(workspace, before, after, operation) {
+  const oldNode = before.get(operation.nodeId) || null;
+  const newNode = after.get(operation.nodeId) || null;
+  const oldRelative = oldNode ? relativePathForNode(before, oldNode.id) : null;
+  const newRelative = newNode ? relativePathForNode(after, newNode.id) : null;
+  const oldPath = oldRelative ? path.join(workspace.path, ...oldRelative.split('/')) : null;
+  const newPath = newRelative ? path.join(workspace.path, ...newRelative.split('/')) : null;
+
+  if (operation.kind === 'tree.create') {
+    requireMissing(newPath, 'create destination already exists');
+    fs.mkdirSync(path.dirname(newPath), { recursive: true });
+    if (operation.nodeKind === 'folder') fs.mkdirSync(newPath);
+    else if (operation.nodeKind === 'symlink') fs.symlinkSync(operation.symlinkTarget, newPath);
+    else fs.writeFileSync(newPath, '');
+  } else if (operation.kind === 'tree.rename' || operation.kind === 'tree.move') {
+    requireMissing(newPath, 'move destination already exists');
+    fs.mkdirSync(path.dirname(newPath), { recursive: true });
+    fs.renameSync(oldPath, newPath);
+  } else if (operation.kind === 'tree.trash') {
+    const destination = trashPath(workspace.id, operation.nodeId);
+    requireMissing(destination, 'trash destination already exists');
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+    fs.renameSync(oldPath, destination);
+  } else if (operation.kind === 'tree.restore') {
+    const source = trashPath(workspace.id, operation.nodeId);
+    requireMissing(newPath, 'restore destination already exists');
+    fs.mkdirSync(path.dirname(newPath), { recursive: true });
+    fs.renameSync(source, newPath);
+  } else if (operation.kind === 'tree.purge') {
+    for (const node of before.values()) {
+      if (node.id === operation.nodeId || descendantsInclude(before, operation.nodeId, node.id)) {
+        fs.rmSync(trashPath(workspace.id, node.id), { recursive: true, force: true });
+      }
+    }
+  }
+
+  return { oldPath, newPath };
+}
+
 function absolutePathForWorkspace(workspaceId, relativePath, database) {
   const workspace = database.prepare('SELECT path FROM workspaces WHERE id = ?').get(workspaceId);
   if (!workspace) throw invalid('workspace not found', 404);
@@ -81,78 +115,32 @@ function persistNodes(database, before, after, workspaceId) {
   const now = new Date().toISOString();
   const pathMemo = new Map();
   const changedPaths = [];
-  const persisted = new Map(
-    database.prepare(
-      'SELECT * FROM workspace_nodes WHERE workspace_id = ?',
-    ).all(workspaceId)
-      .map(rowToNode)
-      .map((node) => [node.id, node]),
-  );
   for (const node of after.values()) {
     const relativePath = relativePathForNode(after, node.id, pathMemo);
-    const previousFromBefore = before.get(node.id);
-    const previous = previousFromBefore || persisted.get(node.id);
-    const previousRelative = previousFromBefore
-      ? relativePathForNode(before, previousFromBefore.id)
-      : previous?.relativePath || null;
-    if (!persisted.has(node.id)) {
+    const previous = before.get(node.id);
+    const previousRelative = previous ? relativePathForNode(before, previous.id) : null;
+    if (!previous) {
       const absolutePath = relativePath ? absolutePathForWorkspace(workspaceId, relativePath, database) : null;
-      const stats = absolutePath && !node.trashedAt && !node.purgedAt
-        ? fs.lstatSync(absolutePath)
-        : null;
+      const stats = absolutePath ? fs.lstatSync(absolutePath) : null;
       database.prepare(`
         INSERT INTO workspace_nodes (
           id, workspace_id, parent_id, kind, name, relative_path, symlink_target,
-          device_id, inode, trashed_at, trash_component_id, purged_at,
-          missing_at, created_at, updated_at
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
-        ON CONFLICT(id) DO UPDATE SET
-          workspace_id = excluded.workspace_id,
-          parent_id = excluded.parent_id,
-          kind = excluded.kind,
-          name = excluded.name,
-          relative_path = excluded.relative_path,
-          symlink_target = excluded.symlink_target,
-          device_id = excluded.device_id,
-          inode = excluded.inode,
-          trashed_at = excluded.trashed_at,
-          trash_component_id = excluded.trash_component_id,
-          purged_at = excluded.purged_at,
-          missing_at = NULL,
-          updated_at = excluded.updated_at
+          device_id, inode, trashed_at, purged_at, missing_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
       `).run(
         node.id, node.workspaceId, node.parentId, node.kind, node.name,
         relativePath, node.symlinkTarget, stats ? String(stats.dev) : null,
-        stats ? String(stats.ino) : null, node.trashedAt,
-        node.trashComponentId, node.purgedAt,
+        stats ? String(stats.ino) : null, node.trashedAt, node.purgedAt,
         node.createdAt, now,
       );
     } else {
       database.prepare(`
         UPDATE workspace_nodes
         SET parent_id = ?, name = ?, relative_path = ?, trashed_at = ?,
-            trash_component_id = ?, purged_at = ?, missing_at = NULL,
-            updated_at = ?
+            purged_at = ?, missing_at = NULL, updated_at = ?
         WHERE id = ?
-      `).run(
-        node.parentId,
-        node.name,
-        relativePath,
-        node.trashedAt,
-        node.trashComponentId,
-        node.purgedAt,
-        now,
-        node.id,
-      );
-      // Trashed and purged rows are UUID tombstones, not live document
-      // locations. Multiple tombstones may legally retain the same logical
-      // path, so only a resulting live node may participate in document path
-      // rebinding.
-      if (
-        previousRelative !== relativePath
-        && !node.trashedAt
-        && !node.purgedAt
-      ) {
+      `).run(node.parentId, node.name, relativePath, node.trashedAt, node.purgedAt, now, node.id);
+      if (previousRelative !== relativePath) {
         changedPaths.push({
           nodeId: node.id,
           oldPath: absolutePathForWorkspace(workspaceId, previousRelative, database),
@@ -177,9 +165,9 @@ function hasAncestorInSet(node, nodesById, ids) {
 
 module.exports = {
   hasAncestorInSet,
+  materializeOperation,
   persistNodes,
   relativePathForNode,
   rowToNode,
-  trashPath,
   workspaceRow,
 };

package/runtime/scripts/amalgm-mcp/workspace/tree/reducer.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { normalizeTreeOperation } = require('./operations');
-const { validateLiveSymlinkTargets } = require('./symlinks');
 
 function toMap(nodes) {
   if (nodes instanceof Map) return new Map(nodes);
@@ -20,25 +19,6 @@ function descendantsInclude(nodes, ancestorId, candidateId) {
   return false;
 }
 
-function descendantIds(nodes, ancestorId) {
-  const children = new Map();
-  for (const node of nodes.values()) {
-    if (!node.parentId) continue;
-    const siblings = children.get(node.parentId) || [];
-    siblings.push(node.id);
-    children.set(node.parentId, siblings);
-  }
-  const descendants = [];
-  const queue = [ancestorId];
-  for (let cursor = 0; cursor < queue.length; cursor += 1) {
-    for (const childId of children.get(queue[cursor]) || []) {
-      descendants.push(childId);
-      queue.push(childId);
-    }
-  }
-  return descendants;
-}
-
 function ensureAvailableName(nodes, workspaceId, parentId, name, exceptId = null) {
   const duplicate = Array.from(nodes.values()).find((node) => (
     node.workspaceId === workspaceId
@@ -71,12 +51,10 @@ function applyTreeOperation(inputNodes, inputOperation) {
       name: operation.name,
       symlinkTarget: operation.symlinkTarget || null,
       trashedAt: null,
-      trashComponentId: null,
       purgedAt: null,
       createdAt: operation.createdAt,
       updatedAt: operation.createdAt,
     });
-    validateLiveSymlinkTargets(nodes, operation.workspaceId);
     return nodes;
   }
 
@@ -94,7 +72,6 @@ function applyTreeOperation(inputNodes, inputOperation) {
   }
 
   const next = { ...existing, updatedAt: operation.changedAt };
-  const existingTrashComponentId = existing.trashComponentId || existing.id;
   if (operation.kind === 'tree.rename') {
     ensureAvailableName(nodes, operation.workspaceId, existing.parentId, operation.name, existing.id);
     next.name = operation.name;
@@ -115,7 +92,6 @@ function applyTreeOperation(inputNodes, inputOperation) {
       throw Object.assign(new Error('a node is already trashed'), { statusCode: 409 });
     }
     next.trashedAt = operation.trashedAt;
-    next.trashComponentId = operation.nodeId;
   } else if (operation.kind === 'tree.restore') {
     if (!existing.trashedAt) {
       throw Object.assign(new Error('a node must be trashed before it can be restored'), { statusCode: 409 });
@@ -133,47 +109,26 @@ function applyTreeOperation(inputNodes, inputOperation) {
     next.parentId = parentId;
     next.name = name;
     next.trashedAt = null;
-    next.trashComponentId = null;
   } else if (operation.kind === 'tree.purge') {
     if (!existing.trashedAt) {
       throw Object.assign(new Error('a node must be trashed before permanent removal'), { statusCode: 409 });
     }
     next.purgedAt = operation.purgedAt;
-    next.trashComponentId = null;
   }
 
   nodes.set(next.id, next);
   if (operation.kind === 'tree.trash' || operation.kind === 'tree.restore' || operation.kind === 'tree.purge') {
-    for (const childId of descendantIds(nodes, next.id)) {
-      const child = nodes.get(childId);
+    for (const child of nodes.values()) {
+      if (child.id === next.id || !descendantsInclude(nodes, next.id, child.id)) continue;
       if (operation.kind === 'tree.trash' && !child.trashedAt) {
-        nodes.set(child.id, {
-          ...child,
-          trashedAt: operation.trashedAt,
-          trashComponentId: operation.nodeId,
-          updatedAt: operation.changedAt,
-        });
-      } else if (
-        operation.kind === 'tree.restore'
-        && (child.trashComponentId || child.id) === existingTrashComponentId
-      ) {
-        nodes.set(child.id, {
-          ...child,
-          trashedAt: null,
-          trashComponentId: null,
-          updatedAt: operation.changedAt,
-        });
+        nodes.set(child.id, { ...child, trashedAt: operation.trashedAt, updatedAt: operation.changedAt });
+      } else if (operation.kind === 'tree.restore' && child.trashedAt === existing.trashedAt) {
+        nodes.set(child.id, { ...child, trashedAt: null, updatedAt: operation.changedAt });
       } else if (operation.kind === 'tree.purge') {
-        nodes.set(child.id, {
-          ...child,
-          trashComponentId: null,
-          purgedAt: operation.purgedAt,
-          updatedAt: operation.changedAt,
-        });
+        nodes.set(child.id, { ...child, purgedAt: operation.purgedAt, updatedAt: operation.changedAt });
       }
     }
   }
-  validateLiveSymlinkTargets(nodes, operation.workspaceId);
   return nodes;
 }
 

package/runtime/scripts/amalgm-mcp/workspace/tree/snapshot.js

@@ -2,7 +2,6 @@
 
 const { isUuid } = require('./identity');
 const { KINDS, normalizeNodeName } = require('./operations');
-const { validateLiveSymlinkTargets } = require('./symlinks');
 
 function invalid(message) {
   throw Object.assign(new Error(message), { statusCode: 400 });
@@ -36,12 +35,6 @@ function normalizeTreeSnapshot(input) {
     }
     const parentId = value.parentId == null ? null : String(value.parentId).toLowerCase();
     if (parentId && !isUuid(parentId)) invalid('workspace tree parent identity is invalid');
-    const trashComponentId = value.trashComponentId == null
-      ? null
-      : String(value.trashComponentId).toLowerCase();
-    if (trashComponentId && !isUuid(trashComponentId)) {
-      invalid('workspace tree trash component identity is invalid');
-    }
     const createdAt = timestamp(value.createdAt, new Date().toISOString());
     const updatedAt = timestamp(value.updatedAt, createdAt);
     if (value.kind === 'symlink' && (typeof value.symlinkTarget !== 'string' || !value.symlinkTarget)) {
@@ -55,7 +48,6 @@ function normalizeTreeSnapshot(input) {
       name: normalizeNodeName(value.name),
       symlinkTarget: value.kind === 'symlink' ? value.symlinkTarget : null,
       trashedAt: value.trashedAt ? timestamp(value.trashedAt) : null,
-      trashComponentId,
       purgedAt: value.purgedAt ? timestamp(value.purgedAt) : null,
       createdAt,
       updatedAt,
@@ -66,30 +58,17 @@ function normalizeTreeSnapshot(input) {
   if (!root || root.parentId !== null || root.kind !== 'folder') {
     invalid('workspace tree requires one folder root whose id is the workspace id');
   }
-  const ancestry = buildAncestryIndex(nodes, workspaceId);
   const siblingNames = new Set();
   for (const node of nodes.values()) {
     if (node.id === workspaceId) continue;
-    if (node.purgedAt) {
-      if (node.trashComponentId) {
-        invalid('a purged workspace tree node cannot name a physical trash component');
-      }
-    } else if (node.trashedAt) {
-      if (!node.trashComponentId) {
-        invalid('an active workspace tree tombstone requires explicit trash provenance');
-      }
-      const component = nodes.get(node.trashComponentId);
-      if (
-        !component
-        || !component.trashedAt
-        || component.purgedAt
-        || component.trashComponentId !== component.id
-        || !isAncestor(ancestry, component.id, node.id)
-      ) {
-        invalid('workspace tree trash component is not an ancestor');
-      }
-    } else if (node.trashComponentId) {
-      invalid('a live workspace tree node cannot name a trash component');
+    if (!node.parentId || !nodes.has(node.parentId)) invalid('workspace tree node parent is missing');
+    const seen = new Set([node.id]);
+    let current = node;
+    while (current.parentId) {
+      if (seen.has(current.parentId)) invalid('workspace tree contains a cycle');
+      seen.add(current.parentId);
+      current = nodes.get(current.parentId);
+      if (!current) invalid('workspace tree node parent is missing');
     }
     if (!node.trashedAt && !node.purgedAt) {
       const key = `${node.parentId}\0${node.name}`;
@@ -97,57 +76,7 @@ function normalizeTreeSnapshot(input) {
       siblingNames.add(key);
     }
   }
-  validateLiveSymlinkTargets(nodes, workspaceId);
   return { schemaVersion: 1, workspaceId, version: input.version, nodes };
 }
 
-function buildAncestryIndex(nodes, rootId) {
-  const children = new Map();
-  for (const node of nodes.values()) {
-    if (node.id === rootId) continue;
-    if (!node.parentId || !nodes.has(node.parentId)) invalid('workspace tree node parent is missing');
-    const siblings = children.get(node.parentId) || [];
-    siblings.push(node.id);
-    children.set(node.parentId, siblings);
-  }
-
-  const entered = new Map();
-  const exited = new Map();
-  const stack = [{ id: rootId, exit: false }];
-  let clock = 0;
-  while (stack.length) {
-    const frame = stack.pop();
-    if (frame.exit) {
-      exited.set(frame.id, clock);
-      clock += 1;
-      continue;
-    }
-    if (entered.has(frame.id)) invalid('workspace tree contains a cycle');
-    entered.set(frame.id, clock);
-    clock += 1;
-    stack.push({ id: frame.id, exit: true });
-    const descendants = children.get(frame.id) || [];
-    for (let index = descendants.length - 1; index >= 0; index -= 1) {
-      stack.push({ id: descendants[index], exit: false });
-    }
-  }
-  if (entered.size !== nodes.size) invalid('workspace tree contains a cycle');
-  return { entered, exited };
-}
-
-function isAncestor(index, ancestorId, nodeId) {
-  const ancestorEntered = index.entered.get(ancestorId);
-  const ancestorExited = index.exited.get(ancestorId);
-  const nodeEntered = index.entered.get(nodeId);
-  const nodeExited = index.exited.get(nodeId);
-  return (
-    ancestorEntered !== undefined
-    && ancestorExited !== undefined
-    && nodeEntered !== undefined
-    && nodeExited !== undefined
-    && ancestorEntered <= nodeEntered
-    && nodeExited <= ancestorExited
-  );
-}
-
 module.exports = { normalizeTreeSnapshot };