sdl-mcp 0.9.2 → 0.9.3

package/dist/db/ladybug-memory.js

@@ -19,39 +19,39 @@ function toMemoryRow(row) {
         deleted: toBoolean(row.deleted),
     };
 }
-const MEMORY_RETURN_FIELDS = `
-  m.memoryId AS memoryId,
-  m.repoId AS repoId,
-  m.type AS type,
-  m.title AS title,
-  m.content AS content,
-  m.contentHash AS contentHash,
-  m.searchText AS searchText,
-  m.tagsJson AS tagsJson,
-  m.confidence AS confidence,
-  m.createdAt AS createdAt,
-  m.updatedAt AS updatedAt,
-  m.createdByVersion AS createdByVersion,
-  m.stale AS stale,
-  m.staleVersion AS staleVersion,
-  m.sourceFile AS sourceFile,
+const MEMORY_RETURN_FIELDS = `
+  m.memoryId AS memoryId,
+  m.repoId AS repoId,
+  m.type AS type,
+  m.title AS title,
+  m.content AS content,
+  m.contentHash AS contentHash,
+  m.searchText AS searchText,
+  m.tagsJson AS tagsJson,
+  m.confidence AS confidence,
+  m.createdAt AS createdAt,
+  m.updatedAt AS updatedAt,
+  m.createdByVersion AS createdByVersion,
+  m.stale AS stale,
+  m.staleVersion AS staleVersion,
+  m.sourceFile AS sourceFile,
   m.deleted AS deleted`;
 export async function upsertMemory(conn, row) {
-    await exec(conn, `MERGE (m:Memory {memoryId: $memoryId})
-     SET m.repoId = $repoId,
-         m.type = $type,
-         m.title = $title,
-         m.content = $content,
-         m.contentHash = $contentHash,
-         m.searchText = $searchText,
-         m.tagsJson = $tagsJson,
-         m.confidence = $confidence,
-         m.createdAt = $createdAt,
-         m.updatedAt = $updatedAt,
-         m.createdByVersion = $createdByVersion,
-         m.stale = $stale,
-         m.staleVersion = $staleVersion,
-         m.sourceFile = $sourceFile,
+    await exec(conn, `MERGE (m:Memory {memoryId: $memoryId})
+     SET m.repoId = $repoId,
+         m.type = $type,
+         m.title = $title,
+         m.content = $content,
+         m.contentHash = $contentHash,
+         m.searchText = $searchText,
+         m.tagsJson = $tagsJson,
+         m.confidence = $confidence,
+         m.createdAt = $createdAt,
+         m.updatedAt = $updatedAt,
+         m.createdByVersion = $createdByVersion,
+         m.stale = $stale,
+         m.staleVersion = $staleVersion,
+         m.sourceFile = $sourceFile,
          m.deleted = $deleted`, {
         memoryId: row.memoryId,
         repoId: row.repoId,
@@ -72,13 +72,13 @@ export async function upsertMemory(conn, row) {
     });
 }
 export async function getMemory(conn, memoryId) {
-    const row = await querySingle(conn, `MATCH (m:Memory {memoryId: $memoryId})
+    const row = await querySingle(conn, `MATCH (m:Memory {memoryId: $memoryId})
      RETURN ${MEMORY_RETURN_FIELDS}`, { memoryId });
     return row ? toMemoryRow(row) : null;
 }
 export async function getMemoryByContentHash(conn, contentHash) {
-    const row = await querySingle(conn, `MATCH (m:Memory {contentHash: $contentHash})
-     WHERE m.deleted = false
+    const row = await querySingle(conn, `MATCH (m:Memory {contentHash: $contentHash})
+     WHERE m.deleted = false
      RETURN ${MEMORY_RETURN_FIELDS}`, { contentHash });
     return row ? toMemoryRow(row) : null;
 }
@@ -88,9 +88,9 @@ export async function queryMemories(conn, options) {
     const useSymbolFilter = options.symbolIds && options.symbolIds.length > 0;
     // When filtering by symbolIds, traverse MEMORY_OF edges
     const matchClause = useSymbolFilter
-        ? `MATCH (m:Memory)-[:MEMORY_OF]->(s:Symbol)
+        ? `MATCH (m:Memory)-[:MEMORY_OF]->(s:Symbol)
        WHERE s.symbolId IN $symbolIds AND m.repoId = $repoId AND m.deleted = false`
-        : `MATCH (m:Memory)
+        : `MATCH (m:Memory)
        WHERE m.repoId = $repoId AND m.deleted = false`;
     const conditions = [];
     const params = { repoId: options.repoId };
@@ -115,9 +115,9 @@ export async function queryMemories(conn, options) {
     const orderBy = options.sortBy === "confidence"
         ? "ORDER BY confidence DESC"
         : "ORDER BY updatedAt DESC";
-    const cypher = `${matchClause}
-     ${whereClause}
-     RETURN DISTINCT ${MEMORY_RETURN_FIELDS}
+    const cypher = `${matchClause}
+     ${whereClause}
+     RETURN DISTINCT ${MEMORY_RETURN_FIELDS}
      ${orderBy}`;
     let rows = await queryAll(conn, cypher, params);
     // Post-filter tags at application level for exact array-element matching
@@ -135,38 +135,38 @@ export async function queryMemories(conn, options) {
     return rows.slice(0, safeLimit).map(toMemoryRow);
 }
 export async function softDeleteMemory(conn, memoryId) {
-    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId})
+    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId})
      SET m.deleted = true`, { memoryId });
 }
 export async function createHasMemoryEdge(conn, repoId, memoryId) {
-    await exec(conn, `MATCH (r:Repo {repoId: $repoId}), (m:Memory {memoryId: $memoryId})
+    await exec(conn, `MATCH (r:Repo {repoId: $repoId}), (m:Memory {memoryId: $memoryId})
      MERGE (r)-[:HAS_MEMORY]->(m)`, { repoId, memoryId });
 }
 export async function createMemoryOfEdge(conn, memoryId, symbolId) {
-    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId}), (s:Symbol {symbolId: $symbolId})
+    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId}), (s:Symbol {symbolId: $symbolId})
      MERGE (m)-[:MEMORY_OF]->(s)`, { memoryId, symbolId });
 }
 export async function createMemoryOfFileEdge(conn, memoryId, fileId) {
-    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId}), (f:File {fileId: $fileId})
+    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId}), (f:File {fileId: $fileId})
      MERGE (m)-[:MEMORY_OF_FILE]->(f)`, { memoryId, fileId });
 }
 export async function deleteMemoryEdges(conn, memoryId) {
     // Delete HAS_MEMORY edges (Repo->Memory)
-    await exec(conn, `MATCH (r:Repo)-[e:HAS_MEMORY]->(m:Memory {memoryId: $memoryId})
+    await exec(conn, `MATCH (r:Repo)-[e:HAS_MEMORY]->(m:Memory {memoryId: $memoryId})
      DELETE e`, { memoryId });
     // Delete MEMORY_OF edges (Memory->Symbol)
-    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId})-[e:MEMORY_OF]->(s:Symbol)
+    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId})-[e:MEMORY_OF]->(s:Symbol)
      DELETE e`, { memoryId });
     // Delete MEMORY_OF_FILE edges (Memory->File)
-    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId})-[e:MEMORY_OF_FILE]->(f:File)
+    await exec(conn, `MATCH (m:Memory {memoryId: $memoryId})-[e:MEMORY_OF_FILE]->(f:File)
      DELETE e`, { memoryId });
 }
 export async function getMemoriesForSymbols(conn, symbolIds, limit) {
     assertSafeInt(limit, "limit");
-    const rows = await queryAll(conn, `MATCH (m:Memory)-[:MEMORY_OF]->(s:Symbol)
-     WHERE s.symbolId IN $symbolIds AND m.deleted = false
-     RETURN ${MEMORY_RETURN_FIELDS},
-            s.symbolId AS linkedSymbolId
+    const rows = await queryAll(conn, `MATCH (m:Memory)-[:MEMORY_OF]->(s:Symbol)
+     WHERE s.symbolId IN $symbolIds AND m.deleted = false
+     RETURN ${MEMORY_RETURN_FIELDS},
+            s.symbolId AS linkedSymbolId
      ORDER BY confidence DESC`, { symbolIds });
     return rows.slice(0, limit).map((row) => ({
         ...toMemoryRow(row),
@@ -175,18 +175,18 @@ export async function getMemoriesForSymbols(conn, symbolIds, limit) {
 }
 export async function getRepoMemories(conn, repoId, limit) {
     assertSafeInt(limit, "limit");
-    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})-[:HAS_MEMORY]->(m:Memory)
-     WHERE m.deleted = false
-     RETURN ${MEMORY_RETURN_FIELDS}
+    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})-[:HAS_MEMORY]->(m:Memory)
+     WHERE m.deleted = false
+     RETURN ${MEMORY_RETURN_FIELDS}
      ORDER BY updatedAt DESC`, { repoId });
     return rows.slice(0, limit).map(toMemoryRow);
 }
 export async function flagMemoriesStale(conn, symbolIds, staleVersion) {
     if (symbolIds.length === 0)
         return 0;
-    const rows = await queryAll(conn, `MATCH (m:Memory)-[:MEMORY_OF]->(s:Symbol)
-     WHERE s.symbolId IN $symbolIds AND m.deleted = false AND m.stale = false
-     SET m.stale = true, m.staleVersion = $staleVersion
+    const rows = await queryAll(conn, `MATCH (m:Memory)-[:MEMORY_OF]->(s:Symbol)
+     WHERE s.symbolId IN $symbolIds AND m.deleted = false AND m.stale = false
+     SET m.stale = true, m.staleVersion = $staleVersion
      RETURN DISTINCT m.memoryId AS memoryId`, { symbolIds, staleVersion });
     return rows.length;
 }

package/dist/db/ladybug-metrics.js

@@ -1,11 +1,11 @@
 import { exec, queryAll, querySingle, toNumber, assertSafeInt, withTransaction, } from "./ladybug-core.js";
 export async function upsertMetrics(conn, metrics) {
-    await exec(conn, `MERGE (m:Metrics {symbolId: $symbolId})
-     SET m.fanIn = $fanIn,
-         m.fanOut = $fanOut,
-         m.churn30d = $churn30d,
-         m.testRefsJson = $testRefsJson,
-         m.canonicalTestJson = $canonicalTestJson,
+    await exec(conn, `MERGE (m:Metrics {symbolId: $symbolId})
+     SET m.fanIn = $fanIn,
+         m.fanOut = $fanOut,
+         m.churn30d = $churn30d,
+         m.testRefsJson = $testRefsJson,
+         m.canonicalTestJson = $canonicalTestJson,
          m.updatedAt = $updatedAt`, {
         symbolId: metrics.symbolId,
         fanIn: metrics.fanIn,
@@ -25,12 +25,12 @@ export async function upsertMetricsBatch(conn, rows) {
         return;
     await withTransaction(conn, async (txConn) => {
         for (const metrics of rows) {
-            await exec(txConn, `MERGE (m:Metrics {symbolId: $symbolId})
-         SET m.fanIn = $fanIn,
-             m.fanOut = $fanOut,
-             m.churn30d = $churn30d,
-             m.testRefsJson = $testRefsJson,
-             m.canonicalTestJson = $canonicalTestJson,
+            await exec(txConn, `MERGE (m:Metrics {symbolId: $symbolId})
+         SET m.fanIn = $fanIn,
+             m.fanOut = $fanOut,
+             m.churn30d = $churn30d,
+             m.testRefsJson = $testRefsJson,
+             m.canonicalTestJson = $canonicalTestJson,
              m.updatedAt = $updatedAt`, {
                 symbolId: metrics.symbolId,
                 fanIn: metrics.fanIn,
@@ -53,8 +53,8 @@ export async function upsertCanonicalTestBatch(conn, rows) {
         return;
     await withTransaction(conn, async (txConn) => {
         for (const row of rows) {
-            await exec(txConn, `MERGE (m:Metrics {symbolId: $symbolId})
-         SET m.canonicalTestJson = $canonicalTestJson,
+            await exec(txConn, `MERGE (m:Metrics {symbolId: $symbolId})
+         SET m.canonicalTestJson = $canonicalTestJson,
              m.updatedAt = $updatedAt`, {
                 symbolId: row.symbolId,
                 canonicalTestJson: row.canonicalTestJson,
@@ -64,13 +64,13 @@ export async function upsertCanonicalTestBatch(conn, rows) {
     });
 }
 export async function getMetrics(conn, symbolId) {
-    const row = await querySingle(conn, `MATCH (m:Metrics {symbolId: $symbolId})
-     RETURN m.symbolId AS symbolId,
-            m.fanIn AS fanIn,
-            m.fanOut AS fanOut,
-            m.churn30d AS churn30d,
-            m.testRefsJson AS testRefsJson,
-            m.canonicalTestJson AS canonicalTestJson,
+    const row = await querySingle(conn, `MATCH (m:Metrics {symbolId: $symbolId})
+     RETURN m.symbolId AS symbolId,
+            m.fanIn AS fanIn,
+            m.fanOut AS fanOut,
+            m.churn30d AS churn30d,
+            m.testRefsJson AS testRefsJson,
+            m.canonicalTestJson AS canonicalTestJson,
             m.updatedAt AS updatedAt`, { symbolId });
     if (!row)
         return null;
@@ -87,14 +87,14 @@ export async function getMetrics(conn, symbolId) {
 export async function getMetricsBySymbolIds(conn, symbolIds) {
     if (symbolIds.length === 0)
         return new Map();
-    const rows = await queryAll(conn, `MATCH (m:Metrics)
-     WHERE m.symbolId IN $symbolIds
-     RETURN m.symbolId AS symbolId,
-            m.fanIn AS fanIn,
-            m.fanOut AS fanOut,
-            m.churn30d AS churn30d,
-            m.testRefsJson AS testRefsJson,
-            m.canonicalTestJson AS canonicalTestJson,
+    const rows = await queryAll(conn, `MATCH (m:Metrics)
+     WHERE m.symbolId IN $symbolIds
+     RETURN m.symbolId AS symbolId,
+            m.fanIn AS fanIn,
+            m.fanOut AS fanOut,
+            m.churn30d AS churn30d,
+            m.testRefsJson AS testRefsJson,
+            m.canonicalTestJson AS canonicalTestJson,
             m.updatedAt AS updatedAt`, { symbolIds });
     const result = new Map();
     for (const row of rows) {
@@ -114,13 +114,13 @@ export async function getTopSymbolsByFanIn(conn, repoId, limit = 10) {
     assertSafeInt(limit, "limit");
     limit = Math.max(0, Math.min(limit, 1000));
     const maxFetch = Math.min(limit, 10000);
-    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)
-     MATCH (m:Metrics {symbolId: s.symbolId})
-     RETURN s.symbolId AS symbolId,
-            m.fanIn AS fanIn,
-            m.fanOut AS fanOut,
-            m.churn30d AS churn30d
-     ORDER BY m.fanIn DESC
+    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)
+     MATCH (m:Metrics {symbolId: s.symbolId})
+     RETURN s.symbolId AS symbolId,
+            m.fanIn AS fanIn,
+            m.fanOut AS fanOut,
+            m.churn30d AS churn30d
+     ORDER BY m.fanIn DESC
      LIMIT $limit`, { repoId, limit: maxFetch });
     return rows.map((row) => ({
         symbolId: row.symbolId,
@@ -130,14 +130,14 @@ export async function getTopSymbolsByFanIn(conn, repoId, limit = 10) {
     }));
 }
 export async function getMetricsByRepo(conn, repoId) {
-    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)
-     MATCH (m:Metrics {symbolId: s.symbolId})
-     RETURN m.symbolId AS symbolId,
-            m.fanIn AS fanIn,
-            m.fanOut AS fanOut,
-            m.churn30d AS churn30d,
-            m.testRefsJson AS testRefsJson,
-            m.canonicalTestJson AS canonicalTestJson,
+    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)
+     MATCH (m:Metrics {symbolId: s.symbolId})
+     RETURN m.symbolId AS symbolId,
+            m.fanIn AS fanIn,
+            m.fanOut AS fanOut,
+            m.churn30d AS churn30d,
+            m.testRefsJson AS testRefsJson,
+            m.canonicalTestJson AS canonicalTestJson,
             m.updatedAt AS updatedAt`, { repoId });
     const result = new Map();
     for (const row of rows) {
@@ -157,13 +157,13 @@ export async function getTopSymbolsByChurn(conn, repoId, limit = 10) {
     assertSafeInt(limit, "limit");
     limit = Math.max(0, Math.min(limit, 1000));
     const maxFetch = Math.min(limit, 10000);
-    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)
-     MATCH (m:Metrics {symbolId: s.symbolId})
-     RETURN s.symbolId AS symbolId,
-            m.fanIn AS fanIn,
-            m.fanOut AS fanOut,
-            m.churn30d AS churn30d
-     ORDER BY m.churn30d DESC
+    const rows = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:SYMBOL_IN_REPO]-(s:Symbol)
+     MATCH (m:Metrics {symbolId: s.symbolId})
+     RETURN s.symbolId AS symbolId,
+            m.fanIn AS fanIn,
+            m.fanOut AS fanOut,
+            m.churn30d AS churn30d
+     ORDER BY m.churn30d DESC
      LIMIT $limit`, { repoId, limit: maxFetch });
     return rows.map((row) => ({
         symbolId: row.symbolId,
@@ -173,10 +173,10 @@ export async function getTopSymbolsByChurn(conn, repoId, limit = 10) {
     }));
 }
 export async function computeFanInOut(conn, symbolId) {
-    const row = await querySingle(conn, `MATCH (s:Symbol {symbolId: $symbolId})
-     OPTIONAL MATCH (s)<-[i:DEPENDS_ON]-(:Symbol)
-     WITH s, count(i) AS fanIn
-     OPTIONAL MATCH (s)-[o:DEPENDS_ON]->(:Symbol)
+    const row = await querySingle(conn, `MATCH (s:Symbol {symbolId: $symbolId})
+     OPTIONAL MATCH (s)<-[i:DEPENDS_ON]-(:Symbol)
+     WITH s, count(i) AS fanIn
+     OPTIONAL MATCH (s)-[o:DEPENDS_ON]->(:Symbol)
      RETURN fanIn AS fanIn, count(o) AS fanOut`, { symbolId });
     if (!row)
         return { fanIn: 0, fanOut: 0 };
@@ -195,18 +195,18 @@ export async function batchComputeFanInOut(conn, symbolIds) {
     // NOTE: Ladybug can produce incorrect counts for large UNWIND lists, especially
     // when the input list contains many missing symbols. Prefer WHERE ... IN and
     // fill missing IDs in JS.
-    const fanInRows = await queryAll(conn, `MATCH (s:Symbol)
-     WHERE s.symbolId IN $symbolIds
-     OPTIONAL MATCH (s)<-[i:DEPENDS_ON]-(:Symbol)
+    const fanInRows = await queryAll(conn, `MATCH (s:Symbol)
+     WHERE s.symbolId IN $symbolIds
+     OPTIONAL MATCH (s)<-[i:DEPENDS_ON]-(:Symbol)
      RETURN s.symbolId AS symbolId, count(i) AS fanIn`, { symbolIds });
     for (const row of fanInRows) {
         const entry = result.get(row.symbolId);
         if (entry)
             entry.fanIn = toNumber(row.fanIn);
     }
-    const fanOutRows = await queryAll(conn, `MATCH (s:Symbol)
-     WHERE s.symbolId IN $symbolIds
-     OPTIONAL MATCH (s)-[o:DEPENDS_ON]->(:Symbol)
+    const fanOutRows = await queryAll(conn, `MATCH (s:Symbol)
+     WHERE s.symbolId IN $symbolIds
+     OPTIONAL MATCH (s)-[o:DEPENDS_ON]->(:Symbol)
      RETURN s.symbolId AS symbolId, count(o) AS fanOut`, { symbolIds });
     for (const row of fanOutRows) {
         const entry = result.get(row.symbolId);

package/dist/db/ladybug-processes.js

@@ -1,13 +1,13 @@
 import { exec, queryAll, querySingle, toNumber, withTransaction, } from "./ladybug-core.js";
 export async function upsertProcess(conn, row) {
-    await exec(conn, `MATCH (r:Repo {repoId: $repoId})
-     MERGE (p:Process {processId: $processId})
-     SET p.repoId = $repoId,
-         p.entrySymbolId = $entrySymbolId,
-         p.label = $label,
-         p.depth = $depth,
-         p.versionId = $versionId,
-         p.createdAt = $createdAt
+    await exec(conn, `MATCH (r:Repo {repoId: $repoId})
+     MERGE (p:Process {processId: $processId})
+     SET p.repoId = $repoId,
+         p.entrySymbolId = $entrySymbolId,
+         p.label = $label,
+         p.depth = $depth,
+         p.versionId = $versionId,
+         p.createdAt = $createdAt
      MERGE (p)-[:PROCESS_IN_REPO]->(r)`, {
         processId: row.processId,
         repoId: row.repoId,
@@ -19,10 +19,10 @@ export async function upsertProcess(conn, row) {
     });
 }
 export async function upsertProcessStep(conn, row) {
-    await exec(conn, `MATCH (s:Symbol {symbolId: $symbolId})
-     MATCH (p:Process {processId: $processId})
-     MERGE (s)-[r:PARTICIPATES_IN]->(p)
-     SET r.stepOrder = $stepOrder,
+    await exec(conn, `MATCH (s:Symbol {symbolId: $symbolId})
+     MATCH (p:Process {processId: $processId})
+     MERGE (s)-[r:PARTICIPATES_IN]->(p)
+     SET r.stepOrder = $stepOrder,
          r.role = $role`, {
         processId: row.processId,
         symbolId: row.symbolId,
@@ -35,10 +35,10 @@ export async function upsertProcessStepsBatch(conn, steps) {
         return;
     await withTransaction(conn, async (txConn) => {
         for (const step of steps) {
-            await exec(txConn, `MATCH (s:Symbol {symbolId: $symbolId})
-         MATCH (p:Process {processId: $processId})
-         MERGE (s)-[r:PARTICIPATES_IN]->(p)
-         SET r.stepOrder = $stepOrder,
+            await exec(txConn, `MATCH (s:Symbol {symbolId: $symbolId})
+         MATCH (p:Process {processId: $processId})
+         MERGE (s)-[r:PARTICIPATES_IN]->(p)
+         SET r.stepOrder = $stepOrder,
              r.role = $role`, {
                 processId: step.processId,
                 symbolId: step.symbolId,
@@ -49,13 +49,13 @@ export async function upsertProcessStepsBatch(conn, steps) {
     });
 }
 export async function getProcessesForSymbol(conn, symbolId) {
-    const rows = await queryAll(conn, `MATCH (s:Symbol {symbolId: $symbolId})-[r:PARTICIPATES_IN]->(p:Process)
-     RETURN p.processId AS processId,
-            p.entrySymbolId AS entrySymbolId,
-            p.label AS label,
-            p.depth AS depth,
-            r.stepOrder AS stepOrder,
-            r.role AS role
+    const rows = await queryAll(conn, `MATCH (s:Symbol {symbolId: $symbolId})-[r:PARTICIPATES_IN]->(p:Process)
+     RETURN p.processId AS processId,
+            p.entrySymbolId AS entrySymbolId,
+            p.label AS label,
+            p.depth AS depth,
+            r.stepOrder AS stepOrder,
+            r.role AS role
      ORDER BY r.stepOrder ASC, processId ASC`, { symbolId });
     return rows.map((row) => ({
         processId: row.processId,
@@ -69,15 +69,15 @@ export async function getProcessesForSymbol(conn, symbolId) {
 export async function getProcessesForSymbols(conn, symbolIds) {
     if (symbolIds.length === 0)
         return new Map();
-    const rows = await queryAll(conn, `MATCH (s:Symbol)-[r:PARTICIPATES_IN]->(p:Process)
-     WHERE s.symbolId IN $symbolIds
-     RETURN s.symbolId AS symbolId,
-            p.processId AS processId,
-            p.entrySymbolId AS entrySymbolId,
-            p.label AS label,
-            p.depth AS depth,
-            r.stepOrder AS stepOrder,
-            r.role AS role
+    const rows = await queryAll(conn, `MATCH (s:Symbol)-[r:PARTICIPATES_IN]->(p:Process)
+     WHERE s.symbolId IN $symbolIds
+     RETURN s.symbolId AS symbolId,
+            p.processId AS processId,
+            p.entrySymbolId AS entrySymbolId,
+            p.label AS label,
+            p.depth AS depth,
+            r.stepOrder AS stepOrder,
+            r.role AS role
      ORDER BY symbolId ASC, r.stepOrder ASC, processId ASC`, { symbolIds });
     const map = new Map();
     for (const row of rows) {
@@ -95,15 +95,15 @@ export async function getProcessesForSymbols(conn, symbolIds) {
     return map;
 }
 export async function getProcessOverviewStats(conn, repoId) {
-    const agg = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:PROCESS_IN_REPO]-(p:Process)
-     RETURN COUNT(p) AS totalProcesses,
-            AVG(p.depth) AS averageDepth,
+    const agg = await querySingle(conn, `MATCH (r:Repo {repoId: $repoId})<-[:PROCESS_IN_REPO]-(p:Process)
+     RETURN COUNT(p) AS totalProcesses,
+            AVG(p.depth) AS averageDepth,
             COUNT(DISTINCT p.entrySymbolId) AS entryPoints`, { repoId });
-    const top = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:PROCESS_IN_REPO]-(p:Process)
-     RETURN p.processId AS processId,
-            p.label AS label,
-            p.depth AS depth
-     ORDER BY depth DESC, processId ASC
+    const top = await queryAll(conn, `MATCH (r:Repo {repoId: $repoId})<-[:PROCESS_IN_REPO]-(p:Process)
+     RETURN p.processId AS processId,
+            p.label AS label,
+            p.depth AS depth
+     ORDER BY depth DESC, processId ASC
      LIMIT 5`, { repoId });
     return {
         totalProcesses: toNumber(agg?.totalProcesses ?? 0),
@@ -117,10 +117,10 @@ export async function getProcessOverviewStats(conn, repoId) {
     };
 }
 export async function getProcessFlow(conn, processId) {
-    const rows = await queryAll(conn, `MATCH (s:Symbol)-[r:PARTICIPATES_IN]->(p:Process {processId: $processId})
-     RETURN s.symbolId AS symbolId,
-            r.stepOrder AS stepOrder,
-            r.role AS role
+    const rows = await queryAll(conn, `MATCH (s:Symbol)-[r:PARTICIPATES_IN]->(p:Process {processId: $processId})
+     RETURN s.symbolId AS symbolId,
+            r.stepOrder AS stepOrder,
+            r.role AS role
      ORDER BY r.stepOrder ASC, symbolId ASC`, { processId });
     return rows.map((row) => ({
         symbolId: row.symbolId,
@@ -129,13 +129,13 @@ export async function getProcessFlow(conn, processId) {
     }));
 }
 export async function getProcessStepsAfterSymbol(conn, processId, symbolId) {
-    const rows = await queryAll(conn, `MATCH (s:Symbol {symbolId: $symbolId})-[r:PARTICIPATES_IN]->(p:Process {processId: $processId})
-     WITH p, r.stepOrder AS startOrder
-     MATCH (s2:Symbol)-[r2:PARTICIPATES_IN]->(p)
-     WHERE r2.stepOrder > startOrder
-     RETURN s2.symbolId AS symbolId,
-            r2.stepOrder AS stepOrder,
-            r2.role AS role
+    const rows = await queryAll(conn, `MATCH (s:Symbol {symbolId: $symbolId})-[r:PARTICIPATES_IN]->(p:Process {processId: $processId})
+     WITH p, r.stepOrder AS startOrder
+     MATCH (s2:Symbol)-[r2:PARTICIPATES_IN]->(p)
+     WHERE r2.stepOrder > startOrder
+     RETURN s2.symbolId AS symbolId,
+            r2.stepOrder AS stepOrder,
+            r2.role AS role
      ORDER BY r2.stepOrder ASC, symbolId ASC`, { processId, symbolId });
     return rows.map((row) => ({
         symbolId: row.symbolId,
@@ -145,12 +145,12 @@ export async function getProcessStepsAfterSymbol(conn, processId, symbolId) {
 }
 export async function deleteProcessesByRepo(conn, repoId) {
     await withTransaction(conn, async (txConn) => {
-        await exec(txConn, `MATCH (p:Process {repoId: $repoId})
-       OPTIONAL MATCH (:Symbol)-[m:PARTICIPATES_IN]->(p)
+        await exec(txConn, `MATCH (p:Process {repoId: $repoId})
+       OPTIONAL MATCH (:Symbol)-[m:PARTICIPATES_IN]->(p)
        DELETE m`, { repoId });
-        await exec(txConn, `MATCH (p:Process {repoId: $repoId})-[rel:PROCESS_IN_REPO]->(:Repo {repoId: $repoId})
+        await exec(txConn, `MATCH (p:Process {repoId: $repoId})-[rel:PROCESS_IN_REPO]->(:Repo {repoId: $repoId})
        DELETE rel`, { repoId });
-        await exec(txConn, `MATCH (p:Process {repoId: $repoId})
+        await exec(txConn, `MATCH (p:Process {repoId: $repoId})
        DELETE p`, { repoId });
     });
 }