@contentful/experience-design-system-cli 2.32.1-dev-build-23e5797.0 → 2.32.1-dev-build-661f431.0

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.32.1-dev-build-23e5797.0",
+  "version": "2.32.1-dev-build-661f431.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",

package/dist/src/index.js

@@ -8472,6 +8472,230 @@ var init_terminal_capabilities = __esm({
   }
 });
 
+// packages/experience-design-system-cli/src/session/source-excerpt.ts
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function identifierPattern(name) {
+  return new RegExp(`(?<![A-Za-z0-9_$])${escapeForRegExp(name)}(?![A-Za-z0-9_$])`);
+}
+function excerptAroundNames(text, names, maxChars, contextLines = 6) {
+  if (text.length <= maxChars) return { content: text, usesNotShown: [] };
+  const patterns = names.filter((name) => name.length > 0).map((name) => ({ name, pattern: identifierPattern(name) }));
+  const lines = text.split("\n");
+  const windows = [];
+  lines.forEach((line, index) => {
+    const mentioned = patterns.filter(({ pattern }) => pattern.test(line)).map(({ name }) => name);
+    if (mentioned.length === 0) return;
+    const start = Math.max(0, index - contextLines);
+    const end = Math.min(lines.length - 1, index + contextLines);
+    const last = windows[windows.length - 1];
+    if (last && start <= last.end + 1) {
+      last.end = Math.max(last.end, end);
+      for (const name of mentioned) last.names.add(name);
+    } else {
+      windows.push({ start, end, names: new Set(mentioned) });
+    }
+  });
+  if (windows.length === 0) {
+    return { content: `${text.slice(0, maxChars)}
+${TRUNCATED_MARKER}`, usesNotShown: [] };
+  }
+  const lastWindowFor = /* @__PURE__ */ new Map();
+  for (const window of windows) for (const name of window.names) lastWindowFor.set(name, window);
+  const kept = [];
+  const cut = /* @__PURE__ */ new Set();
+  let used = 0;
+  for (const window of [...windows].reverse()) {
+    const chunk = lines.slice(window.start, window.end + 1).join("\n");
+    const separator = kept.length > 0 ? `
+${ELLIPSIS_MARKER}
+` : "";
+    if (used + separator.length + chunk.length > maxChars) {
+      if (kept.length === 0) {
+        const head = chunk.slice(0, maxChars);
+        kept.push({ window, text: head });
+        used += head.length;
+        for (const name of window.names) {
+          if (lastWindowFor.get(name) === window && !identifierPattern(name).test(head)) cut.add(name);
+        }
+        continue;
+      }
+      for (const name of window.names) {
+        if (lastWindowFor.get(name) === window) cut.add(name);
+      }
+      continue;
+    }
+    kept.push({ window, text: chunk });
+    used += separator.length + chunk.length;
+  }
+  kept.sort((a, b) => a.window.start - b.window.start);
+  const parts = kept.map((entry, index) => (index > 0 ? `
+${ELLIPSIS_MARKER}
+` : "") + entry.text);
+  const usesNotShown = names.filter((name, index) => cut.has(name) && names.indexOf(name) === index);
+  return { content: `${parts.join("")}
+${TRUNCATED_MARKER}`, usesNotShown };
+}
+var ELLIPSIS_MARKER, TRUNCATED_MARKER;
+var init_source_excerpt = __esm({
+  "packages/experience-design-system-cli/src/session/source-excerpt.ts"() {
+    "use strict";
+    ELLIPSIS_MARKER = "/* \u2026 */";
+    TRUNCATED_MARKER = "/* truncated */";
+  }
+});
+
+// packages/experience-design-system-cli/src/session/core/components/derive-component-id.ts
+import { createHash } from "node:crypto";
+function deriveComponentId(name, source) {
+  return createHash("sha256").update(`${name}:${source}`).digest("hex").slice(0, 12);
+}
+var init_derive_component_id = __esm({
+  "packages/experience-design-system-cli/src/session/core/components/derive-component-id.ts"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-cli/src/session/core/cdf/cdf-mappers.ts
+function mapContentfulTypeToCdfType(contentfulType) {
+  switch (contentfulType.toLowerCase()) {
+    case "string":
+    case "text":
+      return "string";
+    case "richtext":
+      return "richtext";
+    case "media":
+      return "media";
+    case "link":
+      return "link";
+    case "enum":
+    case "symbol":
+      return "enum";
+    case "token":
+      return "token";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+}
+function resolveCdfCategory(contentfulCategory, propName, contentProps, designProps) {
+  if (contentfulCategory && VALID_CATEGORIES2.includes(contentfulCategory)) {
+    return contentfulCategory;
+  }
+  if (contentProps.has(propName)) return "content";
+  if (designProps.has(propName)) return "design";
+  return "state";
+}
+var VALID_CATEGORIES2;
+var init_cdf_mappers = __esm({
+  "packages/experience-design-system-cli/src/session/core/cdf/cdf-mappers.ts"() {
+    "use strict";
+    VALID_CATEGORIES2 = ["content", "design", "state"];
+  }
+});
+
+// packages/experience-design-system-cli/src/session/core/shared/index-rows-by-key.ts
+function indexRowsByKey(items, key) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const k = key(item);
+    let arr = map.get(k);
+    if (!arr) {
+      arr = [];
+      map.set(k, arr);
+    }
+    arr.push(item);
+  }
+  return map;
+}
+var init_index_rows_by_key = __esm({
+  "packages/experience-design-system-cli/src/session/core/shared/index-rows-by-key.ts"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-cli/src/session/repositories/sessions/read.ts
+function getSessionById(db, sessionId2) {
+  const row = db.prepare("SELECT id FROM sessions WHERE id = ?").get(sessionId2);
+  return row ?? null;
+}
+function getLatestCompletedSessionForCommand(db, command) {
+  const row = db.prepare(
+    `SELECT s.id FROM sessions s
+       JOIN steps st ON st.session_id = s.id
+       WHERE st.command = ? AND st.status = 'complete'
+       ORDER BY st.started_at DESC, st.id DESC
+       LIMIT 1`
+  ).get(command);
+  return row?.id ?? null;
+}
+var init_read = __esm({
+  "packages/experience-design-system-cli/src/session/repositories/sessions/read.ts"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-cli/src/session/repositories/sessions/write.ts
+function createSession(db, id, name, timestamp) {
+  db.prepare("INSERT INTO sessions (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)").run(
+    id,
+    name,
+    timestamp,
+    timestamp
+  );
+}
+function updateSessionTimestamp(db, sessionId2, timestamp) {
+  db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(timestamp, sessionId2);
+}
+var init_write = __esm({
+  "packages/experience-design-system-cli/src/session/repositories/sessions/write.ts"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-cli/src/session/repositories/steps/read.ts
+function getSessionIdForStep(db, stepId) {
+  const row = db.prepare("SELECT session_id FROM steps WHERE id = ?").get(stepId);
+  return row?.session_id ?? null;
+}
+var init_read2 = __esm({
+  "packages/experience-design-system-cli/src/session/repositories/steps/read.ts"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-cli/src/session/repositories/steps/write.ts
+function updatePendingStepsToInterrupted(db, sessionId2, command, timestamp) {
+  db.prepare(
+    `UPDATE steps SET status = 'interrupted', completed_at = ?, updated_at = ?
+     WHERE session_id = ? AND command = ? AND status = 'pending'`
+  ).run(timestamp, timestamp, sessionId2, command);
+}
+function createPendingStep(db, sessionId2, command, inputs, timestamp) {
+  const result = db.prepare(
+    `INSERT INTO steps (session_id, command, status, started_at, inputs, outputs, updated_at)
+       VALUES (?, ?, 'pending', ?, ?, '{}', ?)`
+  ).run(sessionId2, command, timestamp, JSON.stringify(inputs), timestamp);
+  return Number(result.lastInsertRowid);
+}
+function updateStepStatus(db, stepId, status, outputs, error, timestamp) {
+  db.prepare(`UPDATE steps SET status = ?, completed_at = ?, outputs = ?, error = ?, updated_at = ? WHERE id = ?`).run(
+    status,
+    timestamp,
+    JSON.stringify(outputs),
+    error,
+    timestamp,
+    stepId
+  );
+}
+var init_write2 = __esm({
+  "packages/experience-design-system-cli/src/session/repositories/steps/write.ts"() {
+    "use strict";
+  }
+});
+
 // packages/experience-design-system-cli/src/session/session-id.ts
 var session_id_exports = {};
 __export(session_id_exports, {
@@ -8696,77 +8920,61 @@ var init_session_id = __esm({
   }
 });
 
-// packages/experience-design-system-cli/src/session/source-excerpt.ts
-function escapeForRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function identifierPattern(name) {
-  return new RegExp(`(?<![A-Za-z0-9_$])${escapeForRegExp(name)}(?![A-Za-z0-9_$])`);
+// packages/experience-design-system-cli/src/session/services/session-resolver.ts
+function getOrCreateSessionForCommand(db, sessionFlag, sessionName, _hints) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (sessionFlag === "new" || sessionFlag === void 0) {
+    const id = generateSessionId();
+    createSession(db, id, sessionName ?? null, now);
+    return { sessionId: id, isNew: true, isResumed: false };
+  }
+  if (!getSessionById(db, sessionFlag)) {
+    throw new Error(`session '${sessionFlag}' not found. Run 'session list' to see active sessions.`);
+  }
+  return { sessionId: sessionFlag, isNew: false, isResumed: false };
 }
-function excerptAroundNames(text, names, maxChars, contextLines = 6) {
-  if (text.length <= maxChars) return { content: text, usesNotShown: [] };
-  const patterns = names.filter((name) => name.length > 0).map((name) => ({ name, pattern: identifierPattern(name) }));
-  const lines = text.split("\n");
-  const windows = [];
-  lines.forEach((line, index) => {
-    const mentioned = patterns.filter(({ pattern }) => pattern.test(line)).map(({ name }) => name);
-    if (mentioned.length === 0) return;
-    const start = Math.max(0, index - contextLines);
-    const end = Math.min(lines.length - 1, index + contextLines);
-    const last = windows[windows.length - 1];
-    if (last && start <= last.end + 1) {
-      last.end = Math.max(last.end, end);
-      for (const name of mentioned) last.names.add(name);
-    } else {
-      windows.push({ start, end, names: new Set(mentioned) });
-    }
-  });
-  if (windows.length === 0) {
-    return { content: `${text.slice(0, maxChars)}
-${TRUNCATED_MARKER}`, usesNotShown: [] };
+var init_session_resolver = __esm({
+  "packages/experience-design-system-cli/src/session/services/session-resolver.ts"() {
+    "use strict";
+    init_session_id();
+    init_read();
+    init_write();
   }
-  const lastWindowFor = /* @__PURE__ */ new Map();
-  for (const window of windows) for (const name of window.names) lastWindowFor.set(name, window);
-  const kept = [];
-  const cut = /* @__PURE__ */ new Set();
-  let used = 0;
-  for (const window of [...windows].reverse()) {
-    const chunk = lines.slice(window.start, window.end + 1).join("\n");
-    const separator = kept.length > 0 ? `
-${ELLIPSIS_MARKER}
-` : "";
-    if (used + separator.length + chunk.length > maxChars) {
-      if (kept.length === 0) {
-        const head = chunk.slice(0, maxChars);
-        kept.push({ window, text: head });
-        used += head.length;
-        for (const name of window.names) {
-          if (lastWindowFor.get(name) === window && !identifierPattern(name).test(head)) cut.add(name);
-        }
-        continue;
-      }
-      for (const name of window.names) {
-        if (lastWindowFor.get(name) === window) cut.add(name);
-      }
-      continue;
-    }
-    kept.push({ window, text: chunk });
-    used += separator.length + chunk.length;
+});
+
+// packages/experience-design-system-cli/src/session/core/components/hash-component-shape.ts
+import { createHash as createHash2 } from "node:crypto";
+function hashComponentShape(component) {
+  const payload = {
+    framework: component.framework,
+    name: component.name,
+    source: component.source,
+    props: component.props.map((p) => ({
+      name: p.name,
+      type: p.type
+    })),
+    slots: component.slots.map((s) => ({
+      name: s.name,
+      isDefault: s.isDefault,
+      allowedComponents: [...s.allowedComponents ?? []].sort()
+    }))
+  };
+  return createHash2("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+var init_hash_component_shape = __esm({
+  "packages/experience-design-system-cli/src/session/core/components/hash-component-shape.ts"() {
+    "use strict";
   }
-  kept.sort((a, b) => a.window.start - b.window.start);
-  const parts = kept.map((entry, index) => (index > 0 ? `
-${ELLIPSIS_MARKER}
-` : "") + entry.text);
-  const usesNotShown = names.filter((name, index) => cut.has(name) && names.indexOf(name) === index);
-  return { content: `${parts.join("")}
-${TRUNCATED_MARKER}`, usesNotShown };
+});
+
+// packages/experience-design-system-cli/src/session/core/tokens/hash-token-content.ts
+import { createHash as createHash3 } from "node:crypto";
+function hashTokenContent(rawTokenContent) {
+  return createHash3("sha256").update(rawTokenContent.trim()).digest("hex");
 }
-var ELLIPSIS_MARKER, TRUNCATED_MARKER;
-var init_source_excerpt = __esm({
-  "packages/experience-design-system-cli/src/session/source-excerpt.ts"() {
+var init_hash_token_content = __esm({
+  "packages/experience-design-system-cli/src/session/core/tokens/hash-token-content.ts"() {
     "use strict";
-    ELLIPSIS_MARKER = "/* \u2026 */";
-    TRUNCATED_MARKER = "/* truncated */";
   }
 });
 
@@ -8777,11 +8985,11 @@ __export(cache_keys_exports, {
   hashFile: () => hashFile,
   hashPromptForSkill: () => hashPromptForSkill
 });
-import { createHash } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { readFile as readFile6 } from "node:fs/promises";
 import { resolve as resolve6 } from "node:path";
 function hashContent(content) {
-  return createHash("sha256").update(content).digest("hex");
+  return createHash4("sha256").update(content).digest("hex");
 }
 async function hashFile(filePath) {
   const content = await readFile6(filePath, "utf8");
@@ -8803,7 +9011,7 @@ var init_cache_keys = __esm({
 import { DatabaseSync } from "node:sqlite";
 import { mkdirSync, readFileSync as readFileSync5 } from "node:fs";
 import { readFile as readFile7 } from "node:fs/promises";
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { homedir } from "node:os";
 import { dirname as dirname7, resolve as resolve7 } from "node:path";
 function getPipelineDbPath() {
@@ -9334,39 +9542,18 @@ function applyToolCalls(db, sessionId2, componentId, componentName, calls, incom
   }
   return { classified, excluded, slots, warnings };
 }
-function getOrCreateSession(db, sessionFlag, sessionName, _hints) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  if (sessionFlag === "new" || sessionFlag === void 0) {
-    const id = generateSessionId();
-    db.prepare("INSERT INTO sessions (id, name, created_at, updated_at) VALUES (?, ?, ?, ?)").run(
-      id,
-      sessionName ?? null,
-      now,
-      now
-    );
-    return { sessionId: id, isNew: true, isResumed: false };
-  }
-  const existing = db.prepare("SELECT id FROM sessions WHERE id = ?").get(sessionFlag);
-  if (!existing) {
-    throw new Error(`session '${sessionFlag}' not found. Run 'session list' to see active sessions.`);
-  }
-  return { sessionId: sessionFlag, isNew: false, isResumed: false };
+function getOrCreateSession(db, sessionFlag, sessionName, hints) {
+  return getOrCreateSessionForCommand(db, sessionFlag, sessionName, hints);
 }
 function createStep(db, sessionId2, command, inputs) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.exec("BEGIN");
   try {
-    db.prepare(
-      `UPDATE steps SET status = 'interrupted', completed_at = ?, updated_at = ?
-       WHERE session_id = ? AND command = ? AND status = 'pending'`
-    ).run(now, now, sessionId2, command);
-    const result = db.prepare(
-      `INSERT INTO steps (session_id, command, status, started_at, inputs, outputs, updated_at)
-         VALUES (?, ?, 'pending', ?, ?, '{}', ?)`
-    ).run(sessionId2, command, now, JSON.stringify(inputs), now);
-    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, sessionId2);
+    updatePendingStepsToInterrupted(db, sessionId2, command, now);
+    const stepId = createPendingStep(db, sessionId2, command, inputs, now);
+    updateSessionTimestamp(db, sessionId2, now);
     db.exec("COMMIT");
-    return Number(result.lastInsertRowid);
+    return stepId;
   } catch (e) {
     db.exec("ROLLBACK");
     throw e;
@@ -9376,12 +9563,10 @@ function updateStep(db, stepId, status, outputs, error) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.exec("BEGIN");
   try {
-    const step = db.prepare("SELECT session_id FROM steps WHERE id = ?").get(stepId);
-    db.prepare(
-      `UPDATE steps SET status = ?, completed_at = ?, outputs = ?, error = ?, updated_at = ? WHERE id = ?`
-    ).run(status, now, JSON.stringify(outputs), error ?? null, now, stepId);
-    if (step) {
-      db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, step.session_id);
+    const stepSessionId = getSessionIdForStep(db, stepId);
+    updateStepStatus(db, stepId, status, outputs, error ?? null, now);
+    if (stepSessionId) {
+      updateSessionTimestamp(db, stepSessionId, now);
     }
     db.exec("COMMIT");
   } catch (e) {
@@ -9579,10 +9764,10 @@ function loadRawComponents(db, sessionId2, allowedNames) {
     `SELECT component_id, slot_name, position, allowed_component
        FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`
   ).all(sessionId2);
-  const propsByComponent = groupBy(props, (p) => p.component_id);
-  const allowedValuesByProp = groupBy(allowedValues, (av) => `${av.component_id}::${av.prop_name}`);
-  const slotsByComponent = groupBy(slots, (s) => s.component_id);
-  const allowedComponentsBySlot = groupBy(allowedComponents, (ac) => `${ac.component_id}::${ac.slot_name}`);
+  const propsByComponent = indexRowsByKey(props, (p) => p.component_id);
+  const allowedValuesByProp = indexRowsByKey(allowedValues, (av) => `${av.component_id}::${av.prop_name}`);
+  const slotsByComponent = indexRowsByKey(slots, (s) => s.component_id);
+  const allowedComponentsBySlot = indexRowsByKey(allowedComponents, (ac) => `${ac.component_id}::${ac.slot_name}`);
   return components.map(
     (c2) => ({
       component_id: c2.component_id,
@@ -9808,22 +9993,6 @@ function parseReviewReasons(raw) {
     return [];
   }
 }
-function groupBy(items, key) {
-  const map = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const k = key(item);
-    let arr = map.get(k);
-    if (!arr) {
-      arr = [];
-      map.set(k, arr);
-    }
-    arr.push(item);
-  }
-  return map;
-}
-function deriveComponentId(name, source) {
-  return createHash2("sha256").update(`${name}:${source}`).digest("hex").slice(0, 12);
-}
 function storeCDFComponents(db, sessionId2, components) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const updateComp = db.prepare(
@@ -9916,7 +10085,7 @@ function storeCDFComponents(db, sessionId2, components) {
           }
         }
       } else {
-        const componentId = createHash2("sha256").update(`${key}:generated`).digest("hex").slice(0, 12);
+        const componentId = deriveComponentId(key, "generated");
         db.prepare(
           `INSERT INTO raw_components (session_id, component_id, name, source, framework, extracted_at, status, description)
            VALUES (?, ?, ?, '', 'react', ?, 'generated', ?)`
@@ -9998,11 +10167,11 @@ function loadCDFComponents(db, sessionId2) {
   const tokenTypeByPath = new Map(
     db.prepare("SELECT path, type FROM raw_tokens WHERE session_id = ?").all(sessionId2).map((token) => [token.path, token.type])
   );
-  const propsByComponent = groupBy(props, (p) => p.component_id);
-  const allowedValuesByProp = groupBy(allowedValues, (av) => `${av.component_id}::${av.prop_name}`);
-  const slotsByComponent = groupBy(slots, (s) => s.component_id);
-  const allowedComponentsBySlot = groupBy(allowedComponents, (ac) => `${ac.component_id}::${ac.slot_name}`);
-  const tokenPathsByProp = groupBy(tokenPaths, (t) => `${t.component_id}::${t.prop_name}`);
+  const propsByComponent = indexRowsByKey(props, (p) => p.component_id);
+  const allowedValuesByProp = indexRowsByKey(allowedValues, (av) => `${av.component_id}::${av.prop_name}`);
+  const slotsByComponent = indexRowsByKey(slots, (s) => s.component_id);
+  const allowedComponentsBySlot = indexRowsByKey(allowedComponents, (ac) => `${ac.component_id}::${ac.slot_name}`);
+  const tokenPathsByProp = indexRowsByKey(tokenPaths, (t) => `${t.component_id}::${t.prop_name}`);
   const toTokenPaths = (rows) => rows === void 0 ? void 0 : rows.map((r) => r.path);
   return components.map(({ component_id, name, description }) => {
     const compProps = propsByComponent.get(component_id) ?? [];
@@ -10067,8 +10236,8 @@ function loadScopeComponents(db, sessionId2) {
     `SELECT component_id, slot_name, position, allowed_component
        FROM raw_slot_allowed_components WHERE session_id = ? ORDER BY component_id, slot_name, position`
   ).all(sessionId2);
-  const slotsByComponent = groupBy(slotRows, (s) => s.component_id);
-  const allowedBySlot = groupBy(allowedRows, (a) => `${a.component_id}::${a.slot_name}`);
+  const slotsByComponent = indexRowsByKey(slotRows, (s) => s.component_id);
+  const allowedBySlot = indexRowsByKey(allowedRows, (a) => `${a.component_id}::${a.slot_name}`);
   return rows.map((r) => {
     const reviewReasons = parseReviewReasons(r.review_reasons);
     const nonAuthorableReason = reviewReasons.find((reason) => reason.startsWith("non-authorable:"));
@@ -10183,14 +10352,7 @@ function loadDTCGTokens(db, sessionId2) {
   return { groups, tokens };
 }
 function findLatestSessionForCommand(db, command) {
-  const row = db.prepare(
-    `SELECT s.id FROM sessions s
-       JOIN steps st ON st.session_id = s.id
-       WHERE st.command = ? AND st.status = 'complete'
-       ORDER BY st.started_at DESC, st.id DESC
-       LIMIT 1`
-  ).get(command);
-  return row?.id ?? null;
+  return getLatestCompletedSessionForCommand(db, command);
 }
 function seedCDFFromPreviewResponse(db, sessionId2, removedItems) {
   if (removedItems.length === 0) return 0;
@@ -10207,14 +10369,8 @@ function seedCDFFromPreviewResponse(db, sessionId2, removedItems) {
     const contentProps = new Set(item.contentProperties);
     const designProps = new Set(item.designProperties);
     for (const [propName, propSummary] of Object.entries(item.fullProperties)) {
-      const cdfType = mapServerTypeToCDFType(propSummary.type);
-      if (!cdfType) continue;
-      let cdfCategory = propSummary.category || null;
-      if (!cdfCategory || !["content", "design", "state"].includes(cdfCategory)) {
-        if (contentProps.has(propName)) cdfCategory = "content";
-        else if (designProps.has(propName)) cdfCategory = "design";
-        else cdfCategory = "state";
-      }
+      const cdfType = mapContentfulTypeToCdfType(propSummary.type);
+      const cdfCategory = resolveCdfCategory(propSummary.category, propName, contentProps, designProps);
       const result = updateStmt.run(cdfType, cdfCategory, sessionId2, localComponent.component_id, propName);
       totalSeeded += Number(result.changes);
     }
@@ -10244,14 +10400,8 @@ function seedDefaultsFromChangedItems(db, sessionId2, changedItems) {
         const result2 = updateDefaultStmt.run(defaultStr, sessionId2, localComponent.component_id, propName);
         totalSeeded += Number(result2.changes);
       }
-      const cdfType = mapServerTypeToCDFType(propSummary.type);
-      if (!cdfType) continue;
-      let cdfCategory = propSummary.category || null;
-      if (!cdfCategory || !["content", "design", "state"].includes(cdfCategory)) {
-        if (contentProps.has(propName)) cdfCategory = "content";
-        else if (designProps.has(propName)) cdfCategory = "design";
-        else cdfCategory = "state";
-      }
+      const cdfType = mapContentfulTypeToCdfType(propSummary.type);
+      const cdfCategory = resolveCdfCategory(propSummary.category, propName, contentProps, designProps);
       const result = updateCDFStmt.run(cdfType, cdfCategory, sessionId2, localComponent.component_id, propName);
       totalSeeded += Number(result.changes);
     }
@@ -10275,48 +10425,6 @@ function backfillUnclassifiedProps(db, sessionId2) {
   ).run(sessionId2, sessionId2);
   return Number(withCategory.changes) + Number(withoutCategory.changes);
 }
-function mapServerTypeToCDFType(serverType) {
-  switch (serverType.toLowerCase()) {
-    case "string":
-    case "text":
-      return "string";
-    case "richtext":
-      return "richtext";
-    case "media":
-      return "media";
-    case "link":
-      return "link";
-    case "enum":
-    case "symbol":
-      return "enum";
-    case "token":
-      return "token";
-    case "boolean":
-      return "boolean";
-    default:
-      return "string";
-  }
-}
-function computeComponentInputHash(component) {
-  const payload = {
-    framework: component.framework,
-    name: component.name,
-    source: component.source,
-    props: component.props.map((p) => ({
-      name: p.name,
-      type: p.type
-    })),
-    slots: component.slots.map((s) => ({
-      name: s.name,
-      isDefault: s.isDefault,
-      allowedComponents: [...s.allowedComponents ?? []].sort()
-    }))
-  };
-  return createHash2("sha256").update(JSON.stringify(payload)).digest("hex");
-}
-function computeTokenInputHash(rawTokenContent) {
-  return createHash2("sha256").update(rawTokenContent.trim()).digest("hex");
-}
 function computeMapTokensInputHash(db, sessionId2, componentSourceRefs = []) {
   const props = db.prepare(
     `SELECT rc.name AS component_name, rp.name AS prop_name, rp.cdf_token_kind, rp.default_value
@@ -10346,7 +10454,7 @@ function computeMapTokensInputHash(db, sessionId2, componentSourceRefs = []) {
       usesNotShown: [...ref.usesNotShown ?? []].sort()
     }))
   };
-  return createHash2("sha256").update(JSON.stringify(payload)).digest("hex");
+  return createHash5("sha256").update(JSON.stringify(payload)).digest("hex");
 }
 function lookupCache(db, inputHash, entityType, entityId, promptHash = "") {
   const row = db.prepare(
@@ -10654,8 +10762,19 @@ var SCHEMA, MAX_COMPONENT_SOURCE_CHARS, MAX_SIBLING_FILES, MAX_SIBLING_SNIPPET_C
 var init_db = __esm({
   "packages/experience-design-system-cli/src/session/db.ts"() {
     "use strict";
-    init_session_id();
     init_source_excerpt();
+    init_derive_component_id();
+    init_cdf_mappers();
+    init_index_rows_by_key();
+    init_read();
+    init_write();
+    init_read2();
+    init_write2();
+    init_session_resolver();
+    init_derive_component_id();
+    init_hash_component_shape();
+    init_hash_token_content();
+    init_cdf_mappers();
     SCHEMA = `
 PRAGMA journal_mode = WAL;
 PRAGMA foreign_keys = ON;
@@ -10932,11 +11051,11 @@ var init_persistence = __esm({
 });
 
 // packages/experience-design-system-cli/src/analyze/select/parser.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 import { access as access2 } from "node:fs/promises";
 import { isAbsolute, relative, resolve as resolve9 } from "node:path";
 function createComponentId(name, resolvedSourcePath) {
-  const sourceHash = createHash3("sha256").update(`${name}:${resolvedSourcePath}`).digest("hex").slice(0, 12);
+  const sourceHash = createHash6("sha256").update(`${name}:${resolvedSourcePath}`).digest("hex").slice(0, 12);
   return `${name}-${sourceHash}`;
 }
 async function resolveComponentSourcePath(source, reviewRoot) {
@@ -17364,7 +17483,7 @@ var init_save_conflict = __esm({
 });
 
 // packages/experience-design-system-cli/src/runs/fingerprint.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { readFile as readFile24, stat as stat5 } from "node:fs/promises";
 import { resolve as resolve23 } from "node:path";
 function rowField(row, key) {
@@ -17372,7 +17491,7 @@ function rowField(row, key) {
   return typeof v === "string" ? v : null;
 }
 function sha256Hex(buf) {
-  return createHash4("sha256").update(buf).digest("hex");
+  return createHash7("sha256").update(buf).digest("hex");
 }
 async function buildSourceFingerprint(opts) {
   const rows = opts.db.prepare("SELECT name, source_path FROM raw_components WHERE session_id = ?").all(opts.extractSessionId);
@@ -30731,7 +30850,7 @@ async function selectAllComponents(agent, model, components, verbose, skillPathO
       try {
         for (let i = 0; i < components.length; i++) {
           const candidate = components[i];
-          const compHash = computeComponentInputHash(candidate.component);
+          const compHash = hashComponentShape(candidate.component);
           const hit = lookupSelectCache(db, compHash, promptHash, cliVersion2);
           if (hit) {
             const finalColor = hit.decision === "accepted" ? c.green : c.red;
@@ -30805,7 +30924,7 @@ async function selectAllComponents(agent, model, components, verbose, skillPathO
           const r = results[i];
           if (!r || r.failed || !r.decision) continue;
           const candidate = components[i];
-          const compHash = computeComponentInputHash(candidate.component);
+          const compHash = hashComponentShape(candidate.component);
           storeSelectCache(db, compHash, promptHash, cliVersion2, r.decision, r.reason ?? null);
         }
       } finally {
@@ -32751,7 +32870,7 @@ function printFallbackInstructions(options) {
 async function runOneComponent(agent, model, db, sessionId2, component, tokensInline, tokenMapInline, index, total, verbose, noCache, skillPathOverride, promptHash, existingContentfulEntities, existingTokensInline) {
   const pos = c.dim(`[${index + 1}/${total}]`);
   if (!noCache) {
-    const inputHash = computeComponentInputHash(component);
+    const inputHash = hashComponentShape(component);
     const cached = lookupCache(db, inputHash, "component", component.component_id, promptHash);
     if (cached) {
       copyComponentFromCache(db, cached.sourceSessionId, sessionId2, component.component_id);
@@ -32874,7 +32993,7 @@ ${outputBuf}`);
     }
     const applied = applyToolCalls(db, sessionId2, component.component_id, component.name, calls, warnings);
     if (!noCache) {
-      const inputHash = computeComponentInputHash(component);
+      const inputHash = hashComponentShape(component);
       storeCache(db, inputHash, "component", component.component_id, sessionId2, false, promptHash);
     }
     return {
@@ -33171,7 +33290,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
   } else if (skill === "tokens") {
     const noCache = opts.cache === false || process.env.EDS_NO_CACHE === "1";
     const tokenInputContent = rawTokensInline ?? "";
-    const tokenInputHash = computeTokenInputHash(tokenInputContent);
+    const tokenInputHash = hashTokenContent(tokenInputContent);
     const db = openPipelineDb();
     try {
       let resolvedSessionId = opts.session;
@@ -33329,7 +33448,7 @@ function registerGenerateCommand(program) {
 // packages/experience-design-system-cli/src/program.ts
 init_command();
 
-// packages/experience-design-system-cli/src/session/command.ts
+// packages/experience-design-system-cli/src/session/cli.ts
 init_db();
 
 // packages/experience-design-system-cli/src/session/stats.ts
@@ -33533,7 +33652,7 @@ function migrateImportDb(db, _now) {
   }
 }
 
-// packages/experience-design-system-cli/src/session/command.ts
+// packages/experience-design-system-cli/src/session/cli.ts
 function parseDuration(str) {
   const m = /^(\d+)([dwmy])$/.exec(str);
   if (!m) return null;

package/dist/src/session/core/cdf/cdf-mappers.d.ts

@@ -0,0 +1,3 @@
+export type CdfCategory = 'content' | 'design' | 'state';
+export declare function mapContentfulTypeToCdfType(contentfulType: string): string;
+export declare function resolveCdfCategory(contentfulCategory: string | null | undefined, propName: string, contentProps: Set<string>, designProps: Set<string>): CdfCategory;

package/dist/src/session/core/components/derive-component-id.d.ts

@@ -0,0 +1 @@
+export declare function deriveComponentId(name: string, source: string): string;

package/dist/src/session/core/components/hash-component-shape.d.ts

@@ -0,0 +1,5 @@
+import type { RawComponentDefinition } from '../../../types.js';
+export type RawComponentForHash = RawComponentDefinition & {
+    component_id?: string;
+};
+export declare function hashComponentShape(component: RawComponentForHash): string;

package/dist/src/session/core/shared/index-rows-by-key.d.ts

@@ -0,0 +1 @@
+export declare function indexRowsByKey<T>(items: T[], key: (item: T) => string): Map<string, T[]>;

package/dist/src/session/core/tokens/hash-token-content.d.ts

@@ -0,0 +1 @@
+export declare function hashTokenContent(rawTokenContent: string): string;

package/dist/src/session/db.d.ts

@@ -4,6 +4,12 @@ import type { CDFComponentEntry, DTCGTokenEntry, DTCGTokenGroup } from '@content
 import type { ToolCall, TokenToolCall, ComponentSourceRef } from '@contentful/experience-design-system-generation';
 import type { ComponentTypeSummary } from '@contentful/experience-design-system-types';
 import type { SlotCycle, SlotEdge } from '../analyze/cycle-detection.js';
+import { type MatchHints as SessionMatchHints } from './repositories/sessions/read.js';
+import { type SessionResolution } from './services/session-resolver.js';
+export { deriveComponentId } from './core/components/derive-component-id.js';
+export { hashComponentShape as computeComponentInputHash } from './core/components/hash-component-shape.js';
+export { hashTokenContent as computeTokenInputHash } from './core/tokens/hash-token-content.js';
+export { mapContentfulTypeToCdfType, resolveCdfCategory } from './core/cdf/cdf-mappers.js';
 export type StepStatus = 'pending' | 'complete' | 'failed' | 'interrupted';
 export type CommandName = 'analyze extract' | 'analyze select' | 'generate components' | 'generate tokens' | 'generate edit' | 'apply preview' | 'apply select' | 'apply push' | 'print components' | 'print tokens' | 'map tokens' | 'fetch existing entities' | 'import';
 export interface SessionRow {
@@ -86,17 +92,9 @@ export interface ComponentRationale {
 }
 export declare function loadComponentRationale(db: DatabaseSync, sessionId: string, componentName: string): ComponentRationale | null;
 export declare function applyToolCalls(db: DatabaseSync, sessionId: string, componentId: string, componentName: string, calls: ToolCall[], incomingWarnings: string[]): ApplyToolCallsResult;
-export interface MatchHints {
-    command: CommandName;
-    inputPath?: string;
-    outDir?: string;
-}
-export interface SessionResolution {
-    sessionId: string;
-    isNew: boolean;
-    isResumed: boolean;
-}
-export declare function getOrCreateSession(db: DatabaseSync, sessionFlag: string | undefined, sessionName: string | undefined, _hints: MatchHints): SessionResolution;
+export type MatchHints = SessionMatchHints;
+export type { SessionResolution };
+export declare function getOrCreateSession(db: DatabaseSync, sessionFlag: string | undefined, sessionName: string | undefined, hints: MatchHints): SessionResolution;
 export declare function createStep(db: DatabaseSync, sessionId: string, command: CommandName, inputs: Record<string, string>): number;
 export declare function updateStep(db: DatabaseSync, stepId: number, status: 'complete' | 'failed', outputs: Record<string, string>, error?: string): void;
 export declare function storeRawComponents(db: DatabaseSync, sessionId: string, components: RawComponentDefinition[], options?: {
@@ -170,8 +168,6 @@ export interface CacheEntry {
     createdAt: string;
     updatedAt: string;
 }
-export declare function computeComponentInputHash(component: RawComponentWithId): string;
-export declare function computeTokenInputHash(rawTokenContent: string): string;
 export declare function computeMapTokensInputHash(db: DatabaseSync, sessionId: string, componentSourceRefs?: readonly ComponentSourceRef[]): string;
 export declare function lookupCache(db: DatabaseSync, inputHash: string, entityType: CacheEntityType, entityId: string, promptHash?: string): CacheEntry | null;
 export declare function lookupCacheByEntity(db: DatabaseSync, entityType: CacheEntityType, entityId: string): CacheEntry | null;

package/dist/src/session/repositories/sessions/read.d.ts

@@ -0,0 +1,11 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { CommandName } from '../../db.js';
+export interface MatchHints {
+    command: CommandName;
+    inputPath?: string;
+    outDir?: string;
+}
+export declare function getSessionById(db: DatabaseSync, sessionId: string): {
+    id: string;
+} | null;
+export declare function getLatestCompletedSessionForCommand(db: DatabaseSync, command: CommandName): string | null;

package/dist/src/session/repositories/sessions/write.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseSync } from 'node:sqlite';
+export declare function createSession(db: DatabaseSync, id: string, name: string | null, timestamp: string): void;
+export declare function updateSessionTimestamp(db: DatabaseSync, sessionId: string, timestamp: string): void;

package/dist/src/session/repositories/steps/read.d.ts

@@ -0,0 +1,2 @@
+import type { DatabaseSync } from 'node:sqlite';
+export declare function getSessionIdForStep(db: DatabaseSync, stepId: number): string | null;

package/dist/src/session/repositories/steps/write.d.ts

@@ -0,0 +1,5 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { CommandName } from '../../db.js';
+export declare function updatePendingStepsToInterrupted(db: DatabaseSync, sessionId: string, command: CommandName, timestamp: string): void;
+export declare function createPendingStep(db: DatabaseSync, sessionId: string, command: CommandName, inputs: Record<string, string>, timestamp: string): number;
+export declare function updateStepStatus(db: DatabaseSync, stepId: number, status: 'complete' | 'failed', outputs: Record<string, string>, error: string | null, timestamp: string): void;

package/dist/src/session/services/session-resolver.d.ts

@@ -0,0 +1,9 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { type MatchHints } from '../repositories/sessions/read.js';
+export type { MatchHints };
+export interface SessionResolution {
+    sessionId: string;
+    isNew: boolean;
+    isResumed: boolean;
+}
+export declare function getOrCreateSessionForCommand(db: DatabaseSync, sessionFlag: string | undefined, sessionName: string | undefined, _hints: MatchHints): SessionResolution;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.32.1-dev-build-23e5797.0",
+  "version": "2.32.1-dev-build-661f431.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -40,8 +40,8 @@
     "svelte": "^5.56.4",
     "ts-morph": "^27.0.2",
     "typescript": "^5.9.3",
-    "@contentful/experience-design-system-cli-v2": "2.32.1-dev-build-23e5797.0",
-    "@contentful/experience-design-system-types": "2.32.1-dev-build-23e5797.0"
+    "@contentful/experience-design-system-types": "2.32.1-dev-build-661f431.0",
+    "@contentful/experience-design-system-cli-v2": "2.32.1-dev-build-661f431.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.4",
@@ -53,9 +53,9 @@
     "ink-testing-library": "^4.0.0",
     "typescript-eslint": "^8.67.0",
     "vitest": "^4.0.16",
-    "@contentful/experience-design-system-extraction": "2.32.1-dev-build-23e5797.0",
-    "@contentful/experience-design-system-client": "2.32.1-dev-build-23e5797.0",
-    "@contentful/experience-design-system-generation": "2.32.1-dev-build-23e5797.0"
+    "@contentful/experience-design-system-generation": "2.32.1-dev-build-661f431.0",
+    "@contentful/experience-design-system-client": "2.32.1-dev-build-661f431.0",
+    "@contentful/experience-design-system-extraction": "2.32.1-dev-build-661f431.0"
   },
   "repository": {
     "type": "git",