sdtk-design-kit 0.1.0 → 0.1.2

package/src/lib/design-input-contract.js

@@ -0,0 +1,423 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { describeDesignPaths, resolveProjectPath } = require("./design-paths");
+const { resolveProfile } = require("./design-profiles");
+const { ValidationError } = require("./errors");
+
+function toPosixRelative(basePath, targetPath) {
+  return path.relative(basePath, targetPath).split(path.sep).join("/");
+}
+
+function findArtifactByPattern(rootPath, relativeDir, pattern) {
+  const absoluteDir = path.join(rootPath, relativeDir);
+  if (!fs.existsSync(absoluteDir) || !fs.statSync(absoluteDir).isDirectory()) {
+    return null;
+  }
+  const entries = fs
+    .readdirSync(absoluteDir, { withFileTypes: true })
+    .filter((entry) => entry.isFile() && pattern.test(entry.name))
+    .map((entry) => entry.name)
+    .sort();
+  if (entries.length === 0) {
+    return null;
+  }
+  const fileName = entries[0];
+  const absolutePath = path.join(absoluteDir, fileName);
+  return {
+    relativePath: `${relativeDir.replace(/\\/g, "/")}/${fileName}`,
+    absolutePath,
+  };
+}
+
+function resolveReferenceDirectory(value, projectPath) {
+  if (!value) {
+    return { provided: false, status: "NOT_PROVIDED", absolutePath: null };
+  }
+  const absolutePath = path.resolve(projectPath, value);
+  if (!fs.existsSync(absolutePath) || !fs.statSync(absolutePath).isDirectory()) {
+    throw new ValidationError(`--reference-dir is not a valid directory: ${absolutePath}. No project files were changed.`);
+  }
+  return {
+    provided: true,
+    status: "READY_READ_ONLY",
+    absolutePath,
+  };
+}
+
+function listFilesRecursive(rootDirectory) {
+  const results = [];
+  const stack = [rootDirectory];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    const entries = fs.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(absolutePath);
+        continue;
+      }
+      if (entry.isFile()) {
+        results.push(absolutePath);
+      }
+    }
+  }
+  results.sort();
+  return results;
+}
+
+function tokenSet(value) {
+  return new Set(
+    String(value || "")
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, " ")
+      .split(" ")
+      .map((token) => token.trim())
+      .filter(Boolean)
+  );
+}
+
+function readHtmlHints(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const titleMatch = raw.match(/<title[^>]*>(.*?)<\/title>/i);
+    const headingMatch = raw.match(/<h[1-2][^>]*>(.*?)<\/h[1-2]>/i);
+    return {
+      title: titleMatch ? titleMatch[1].replace(/<[^>]+>/g, " ").trim() : "",
+      heading: headingMatch ? headingMatch[1].replace(/<[^>]+>/g, " ").trim() : "",
+    };
+  } catch (_err) {
+    return { title: "", heading: "" };
+  }
+}
+
+function confidenceFromScore(score) {
+  if (score >= 4) return "high";
+  if (score >= 2) return "medium";
+  if (score >= 1) return "low";
+  return "low";
+}
+
+function mapReferenceFiles({ referenceDir, screens }) {
+  const files = listFilesRecursive(referenceDir);
+  const entries = [];
+  const screenTargets = Array.isArray(screens) ? screens : [];
+  const supportedExtensions = new Set([".html", ".htm", ".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg"]);
+  for (const absolutePath of files) {
+    const relativePath = toPosixRelative(referenceDir, absolutePath);
+    const extension = path.extname(absolutePath).toLowerCase();
+    if (!supportedExtensions.has(extension)) {
+      entries.push({
+        sourceFileRelativePath: relativePath,
+        fileType: extension || "unknown",
+        mappedScreenId: null,
+        mappedScreenTitle: null,
+        confidence: "low",
+        evidenceNotes: ["unsupported file type"],
+        status: "unmapped",
+      });
+      continue;
+    }
+
+    const baseTokens = tokenSet(path.basename(absolutePath, extension));
+    const htmlHints = extension === ".html" || extension === ".htm" ? readHtmlHints(absolutePath) : { title: "", heading: "" };
+    const titleTokens = tokenSet(htmlHints.title);
+    const headingTokens = tokenSet(htmlHints.heading);
+
+    let bestMatch = null;
+    for (const screen of screenTargets) {
+      const screenTokens = tokenSet(`${screen.screenId} ${screen.title}`);
+      let score = 0;
+      const evidence = [];
+      for (const token of screenTokens) {
+        if (baseTokens.has(token)) {
+          score += 2;
+          evidence.push(`filename token match: ${token}`);
+        }
+        if (titleTokens.has(token)) {
+          score += 1;
+          evidence.push(`title token match: ${token}`);
+        }
+        if (headingTokens.has(token)) {
+          score += 1;
+          evidence.push(`heading token match: ${token}`);
+        }
+      }
+      if (!bestMatch || score > bestMatch.score) {
+        bestMatch = { score, screen, evidence };
+      }
+    }
+
+    if (!bestMatch || bestMatch.score <= 0) {
+      entries.push({
+        sourceFileRelativePath: relativePath,
+        fileType: extension,
+        mappedScreenId: null,
+        mappedScreenTitle: null,
+        confidence: "low",
+        evidenceNotes: ["no deterministic filename/title/heading match"],
+        status: "unmapped",
+      });
+      continue;
+    }
+
+    entries.push({
+      sourceFileRelativePath: relativePath,
+      fileType: extension,
+      mappedScreenId: bestMatch.screen.screenId,
+      mappedScreenTitle: bestMatch.screen.title,
+      confidence: confidenceFromScore(bestMatch.score),
+      evidenceNotes: bestMatch.evidence,
+      status: "mapped",
+    });
+  }
+
+  return {
+    totalFiles: entries.length,
+    mappedCount: entries.filter((entry) => entry.status === "mapped").length,
+    unmappedCount: entries.filter((entry) => entry.status !== "mapped").length,
+    entries,
+  };
+}
+
+function writeInputContractState(projectPath, statePayload) {
+  const paths = describeDesignPaths(projectPath);
+  fs.mkdirSync(paths.designStatePath, { recursive: true });
+  fs.writeFileSync(paths.designStartInputStatePath, `${JSON.stringify(statePayload, null, 2)}\n`, "utf-8");
+  return paths.designStartInputStatePath;
+}
+
+function toScreenId(value) {
+  return String(value || "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+}
+
+function normalizedScreenRecord(raw, sourceArtifact, fallbackTitle) {
+  const title = String(
+    (raw && (raw.title || raw.name || raw.screen || raw.label || raw.id)) || fallbackTitle || ""
+  ).trim();
+  if (!title) {
+    return null;
+  }
+  const screenId = toScreenId((raw && (raw.id || raw.slug)) || title);
+  const route = raw && typeof raw.route === "string" ? raw.route.trim() : "";
+  const purpose = raw && typeof raw.purpose === "string" ? raw.purpose.trim() : "";
+  const primaryAction = raw && typeof raw.primaryAction === "string" ? raw.primaryAction.trim() : "";
+  const majorSections = Array.isArray(raw && raw.majorSections)
+    ? raw.majorSections.map((value) => String(value).trim()).filter(Boolean)
+    : [];
+  const requiredStates = Array.isArray(raw && raw.requiredStates)
+    ? raw.requiredStates.map((value) => String(value).trim()).filter(Boolean)
+    : [];
+  const populatedCount = [route, purpose, primaryAction].filter(Boolean).length + (majorSections.length > 0 ? 1 : 0) + (requiredStates.length > 0 ? 1 : 0);
+  const confidence = populatedCount >= 3 ? "high" : populatedCount >= 1 ? "medium" : "low";
+  return {
+    screenId,
+    title,
+    route: route || null,
+    purpose: purpose || null,
+    primaryAction: primaryAction || null,
+    majorSections,
+    requiredStates,
+    sourceArtifact,
+    sourceStatus: "explicit",
+    confidence,
+  };
+}
+
+function extractScreensFromHandoffJson(handoffPath, relativePath) {
+  const raw = fs.readFileSync(handoffPath, "utf-8");
+  let payload = null;
+  try {
+    payload = JSON.parse(raw);
+  } catch (_err) {
+    return [];
+  }
+  const candidateArrays = [
+    payload && payload.screens,
+    payload && payload.screenInventory,
+    payload && payload.screen_inventory,
+    payload && payload.screenList,
+    payload && payload.screen_list,
+  ].filter(Array.isArray);
+  const screens = [];
+  for (const candidateArray of candidateArrays) {
+    for (const item of candidateArray) {
+      const record =
+        typeof item === "string"
+          ? normalizedScreenRecord({ title: item }, relativePath, item)
+          : normalizedScreenRecord(item || {}, relativePath, "");
+      if (record) {
+        screens.push(record);
+      }
+    }
+  }
+  return screens;
+}
+
+function extractScreensFromInventoryMarkdown(inventoryPath, relativePath) {
+  const lines = fs.readFileSync(inventoryPath, "utf-8").split(/\r?\n/);
+  const screens = [];
+  for (const line of lines) {
+    const headingMatch = line.match(/^###\s+(.+?)\s*$/);
+    if (headingMatch) {
+      const record = normalizedScreenRecord({ title: headingMatch[1] }, relativePath, headingMatch[1]);
+      if (record) screens.push(record);
+      continue;
+    }
+    const listMatch = line.match(/^\s*-\s+(.+?)\s*$/);
+    if (listMatch) {
+      const candidate = listMatch[1].replace(/`/g, "").trim();
+      if (!candidate || candidate.includes(":")) {
+        continue;
+      }
+      const record = normalizedScreenRecord({ title: candidate }, relativePath, candidate);
+      if (record) screens.push(record);
+    }
+  }
+  return screens;
+}
+
+function dedupeScreens(screens) {
+  const byId = new Map();
+  for (const screen of screens) {
+    if (!screen || !screen.screenId) {
+      continue;
+    }
+    if (!byId.has(screen.screenId)) {
+      byId.set(screen.screenId, screen);
+      continue;
+    }
+    const existing = byId.get(screen.screenId);
+    const existingScore = (existing.route ? 1 : 0) + (existing.purpose ? 1 : 0) + (existing.primaryAction ? 1 : 0) + existing.majorSections.length + existing.requiredStates.length;
+    const newScore = (screen.route ? 1 : 0) + (screen.purpose ? 1 : 0) + (screen.primaryAction ? 1 : 0) + screen.majorSections.length + screen.requiredStates.length;
+    if (newScore > existingScore) {
+      byId.set(screen.screenId, screen);
+    }
+  }
+  return Array.from(byId.values());
+}
+
+function buildInputContractState({
+  fromSpecPath,
+  projectPath,
+  designBriefPath,
+  referenceDir,
+  profile,
+}) {
+  const resolvedProjectPath = resolveProjectPath(projectPath || process.cwd());
+  const resolvedSpecPath = resolveProjectPath(fromSpecPath || resolvedProjectPath);
+  if (!fs.existsSync(resolvedSpecPath) || !fs.statSync(resolvedSpecPath).isDirectory()) {
+    throw new ValidationError(`--from-spec is not a valid directory: ${resolvedSpecPath}. No project files were changed.`);
+  }
+
+  const selectedProfile = resolveProfile(profile);
+
+  const artifactRules = [
+    { key: "designHandoff", relativeDir: "docs/design", pattern: /^SPEC_TO_DESIGN_HANDOFF_.*\.json$/i, blocker: "NEEDS_DESIGN_HANDOFF" },
+    { key: "screenInventory", relativeDir: "docs/design", pattern: /^SCREEN_INVENTORY_.*\.md$/i, blocker: null },
+    { key: "userFlows", relativeDir: "docs/design", pattern: /^USER_FLOWS_.*\.md$/i, blocker: "NEEDS_USER_FLOWS" },
+    { key: "domainModel", relativeDir: "docs/specs", pattern: /^DOMAIN_MODEL_.*\.md$/i, blocker: "NEEDS_DOMAIN_MODEL" },
+    { key: "archDesign", relativeDir: "docs/architecture", pattern: /^ARCH_DESIGN_.*\.md$/i, blocker: null },
+    { key: "baSpec", relativeDir: "docs/specs", pattern: /^BA_SPEC_.*\.md$/i, blocker: null },
+  ];
+
+  const artifacts = {};
+  for (const rule of artifactRules) {
+    artifacts[rule.key] = findArtifactByPattern(resolvedSpecPath, rule.relativeDir, rule.pattern);
+  }
+
+  let explicitDesignBrief = null;
+  if (designBriefPath) {
+    const absoluteDesignBrief = path.resolve(resolvedProjectPath, designBriefPath);
+    if (!fs.existsSync(absoluteDesignBrief) || !fs.statSync(absoluteDesignBrief).isFile()) {
+      throw new ValidationError(`--design-brief is not a valid file: ${absoluteDesignBrief}. No project files were changed.`);
+    }
+    explicitDesignBrief = {
+      absolutePath: absoluteDesignBrief,
+      relativeToProject: toPosixRelative(resolvedProjectPath, absoluteDesignBrief),
+    };
+  }
+
+  const reference = resolveReferenceDirectory(referenceDir, resolvedProjectPath);
+  const parsedScreens = [];
+  if (artifacts.designHandoff) {
+    parsedScreens.push(
+      ...extractScreensFromHandoffJson(artifacts.designHandoff.absolutePath, artifacts.designHandoff.relativePath)
+    );
+  }
+  if (artifacts.screenInventory) {
+    parsedScreens.push(
+      ...extractScreensFromInventoryMarkdown(artifacts.screenInventory.absolutePath, artifacts.screenInventory.relativePath)
+    );
+  }
+  const screens = dedupeScreens(parsedScreens);
+
+  const blockers = artifactRules.filter((rule) => rule.blocker && !artifacts[rule.key]).map((rule) => rule.blocker);
+  if (screens.length === 0) {
+    blockers.push("NEEDS_SCREEN_INVENTORY");
+  }
+  const analysisStatus = blockers.length === 0 ? "INPUT_CONTRACT_READY" : "INPUT_CONTRACT_BLOCKED";
+
+  const artifactSummary = {};
+  for (const rule of artifactRules) {
+    const value = artifacts[rule.key];
+    artifactSummary[rule.key] = value
+      ? {
+          found: true,
+          relativeToSpecRoot: value.relativePath,
+          absolutePath: value.absolutePath,
+        }
+      : {
+          found: false,
+          relativeToSpecRoot: null,
+          absolutePath: null,
+        };
+  }
+
+  return {
+    schema: "sdtk.design.input-contract.v1",
+    mode: "from-spec",
+    projectPath: resolvedProjectPath,
+    fromSpecPath: resolvedSpecPath,
+    profileSelection: selectedProfile ? selectedProfile.name : null,
+    profilePrimitives: selectedProfile
+      ? {
+          name: selectedProfile.name,
+          summary: selectedProfile.summary,
+          primitives: selectedProfile.primitives,
+          screenRoleHints: selectedProfile.screenRoleHints,
+        }
+      : null,
+    explicitDesignBrief,
+    referenceDirectory: {
+      provided: reference.provided,
+      status: reference.status,
+      absolutePath: reference.absolutePath,
+    },
+    referenceMap: reference.provided
+      ? mapReferenceFiles({ referenceDir: reference.absolutePath, screens })
+      : { totalFiles: 0, mappedCount: 0, unmappedCount: 0, entries: [] },
+    artifacts: artifactSummary,
+    screenModel: {
+      totalScreens: screens.length,
+      missingMetadataCount: screens.filter((screen) => !screen.route || !screen.purpose || !screen.primaryAction).length,
+      legacyFallbackUsed: false,
+      readiness: screens.length > 0 ? "MULTI_SCREEN_READY" : "NEEDS_EXPLICIT_SCREEN_INPUT",
+      screens,
+    },
+    blockers,
+    analysisStatus,
+    nextRecommendedCommand:
+      blockers.length > 0 ? "Provide missing explicit SPEC/design artifacts and re-run sdtk-design start --from-spec." : "sdtk-design prototype",
+  };
+}
+
+module.exports = {
+  buildInputContractState,
+  writeInputContractState,
+};

package/src/lib/design-paths.js

@@ -5,6 +5,8 @@ const path = require("path");
 const DESIGN_DOCS_RELATIVE = path.join("docs", "design");
 const DESIGN_WIREFRAMES_RELATIVE = path.join("docs", "design", "wireframes");
 const DESIGN_REVIEWS_RELATIVE = path.join("docs", "design", "reviews");
+const DESIGN_PROTOTYPE_RELATIVE = path.join("docs", "design", "prototype");
+const DESIGN_PROTOTYPE_INDEX_RELATIVE = path.join("docs", "design", "prototype", "index.html");
 const DESIGN_README_RELATIVE = path.join("docs", "design", "README.md");
 const DESIGN_BRIEF_RELATIVE = path.join("docs", "design", "DESIGN_BRIEF.md");
 const DESIGN_SCREEN_MAP_RELATIVE = path.join("docs", "design", "SCREEN_MAP.md");
@@ -12,6 +14,7 @@ const DESIGN_SYSTEM_RELATIVE = path.join("docs", "design", "DESIGN_SYSTEM.md");
 const DESIGN_HANDOFF_RELATIVE = path.join("docs", "design", "DESIGN_HANDOFF.md");
 const DESIGN_STATE_RELATIVE = path.join(".sdtk", "design");
 const DESIGN_MANIFEST_RELATIVE = path.join(".sdtk", "design", "manifest.json");
+const DESIGN_START_INPUT_STATE_RELATIVE = path.join(".sdtk", "design", "START_INPUT_STATE.json");
 
 function resolveProjectPath(projectPath) {
   return path.resolve(projectPath || process.cwd());
@@ -44,6 +47,8 @@ function describeDesignPaths(projectPath) {
     designDocsPath: path.join(root, DESIGN_DOCS_RELATIVE),
     wireframesPath: path.join(root, DESIGN_WIREFRAMES_RELATIVE),
     reviewsPath: path.join(root, DESIGN_REVIEWS_RELATIVE),
+    prototypePath: path.join(root, DESIGN_PROTOTYPE_RELATIVE),
+    prototypeIndexPath: path.join(root, DESIGN_PROTOTYPE_INDEX_RELATIVE),
     designReadmePath: path.join(root, DESIGN_README_RELATIVE),
     designBriefPath: path.join(root, DESIGN_BRIEF_RELATIVE),
     screenMapPath: path.join(root, DESIGN_SCREEN_MAP_RELATIVE),
@@ -51,6 +56,7 @@ function describeDesignPaths(projectPath) {
     designHandoffPath: path.join(root, DESIGN_HANDOFF_RELATIVE),
     designStatePath: path.join(root, DESIGN_STATE_RELATIVE),
     manifestPath: path.join(root, DESIGN_MANIFEST_RELATIVE),
+    designStartInputStatePath: path.join(root, DESIGN_START_INPUT_STATE_RELATIVE),
   };
 }
 
@@ -59,9 +65,12 @@ module.exports = {
   DESIGN_DOCS_RELATIVE,
   DESIGN_HANDOFF_RELATIVE,
   DESIGN_MANIFEST_RELATIVE,
+  DESIGN_PROTOTYPE_INDEX_RELATIVE,
+  DESIGN_PROTOTYPE_RELATIVE,
   DESIGN_README_RELATIVE,
   DESIGN_REVIEWS_RELATIVE,
   DESIGN_SCREEN_MAP_RELATIVE,
+  DESIGN_START_INPUT_STATE_RELATIVE,
   DESIGN_STATE_RELATIVE,
   DESIGN_SYSTEM_RELATIVE,
   DESIGN_WIREFRAMES_RELATIVE,

package/src/lib/design-profiles.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const { ValidationError } = require("./errors");
+
+const DESIGN_PROFILES = {
+  "b2b-commerce": {
+    name: "b2b-commerce",
+    summary: "Reusable B2B commerce primitives for multi-screen product catalogs and purchasing workflows.",
+    primitives: [
+      "catalog grid",
+      "filter sidebar",
+      "product card",
+      "pdp gallery/spec/cta",
+      "search results/no-result",
+      "cart line items/summary",
+      "checkout steps",
+      "order history/detail",
+      "account shell",
+      "configurator wizard",
+      "bom/material table",
+    ],
+    screenRoleHints: {
+      home: ["catalog grid", "product card", "sticky purchase/cta"],
+      category: ["filter sidebar", "catalog grid", "product card"],
+      "product-detail": ["pdp gallery/spec/cta", "sticky purchase/cta"],
+      search: ["search results/no-result", "product card", "filter sidebar"],
+      cart: ["cart line items/summary", "sticky purchase/cta"],
+      checkout: ["checkout steps", "cart line items/summary", "sticky purchase/cta"],
+      "order-history": ["order history/detail"],
+      "order-detail": ["order history/detail"],
+      "account-info": ["account shell"],
+      "mode-b-configurator": ["configurator wizard", "bom/material table", "sticky purchase/cta"],
+    },
+  },
+};
+
+function availableProfileNames() {
+  return Object.keys(DESIGN_PROFILES);
+}
+
+function resolveProfile(profileName) {
+  if (!profileName) {
+    return null;
+  }
+  const normalized = String(profileName).trim().toLowerCase();
+  if (DESIGN_PROFILES[normalized]) {
+    return DESIGN_PROFILES[normalized];
+  }
+  throw new ValidationError(
+    `Unsupported --profile "${profileName}". Supported profiles: ${availableProfileNames().join(", ")}. No project files were changed.`
+  );
+}
+
+module.exports = {
+  DESIGN_PROFILES,
+  availableProfileNames,
+  resolveProfile,
+};

package/src/lib/domain-profile.js

@@ -0,0 +1,108 @@
+"use strict";
+
+function normalizeText(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+
+function extractSourceIdea(briefContent) {
+  const match = String(briefContent || "").match(/## Source Idea\s+([\s\S]*?)(?:\n## |\s*$)/i);
+  return normalizeText(match ? match[1] : "");
+}
+
+function extractProductName(sourceIdea, crmLike) {
+  const clean = normalizeText(sourceIdea);
+  const namedBuild = clean.match(/\bbuild\s+([A-Z][A-Za-z0-9-]{2,40})(?:,|\s+for|\s+to|\s+that|\s+-)/);
+  if (namedBuild) return namedBuild[1];
+  return crmLike ? "Client Workspace" : "MVP Workspace";
+}
+
+function slugify(value) {
+  const slug = normalizeText(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+  return slug || "mvp-workspace";
+}
+
+function inferDomainProfile({ briefContent = "", screenMapContent = "", designSystemContent = "", wireframeContents = [] } = {}) {
+  const sourceIdea = extractSourceIdea(briefContent);
+  const combined = normalizeText([sourceIdea, briefContent, screenMapContent, designSystemContent, ...wireframeContents].join(" "));
+  const domainSource = normalizeText([sourceIdea, briefContent].join(" "));
+  const lower = domainSource.toLowerCase();
+  const crmLike = /\b(crm|lead|leads|pipeline|follow-up|follow up|consultant|client conversation|opportunity)\b/.test(lower);
+  const productName = extractProductName(sourceIdea || combined, crmLike);
+  const slug = slugify(productName);
+
+  if (crmLike) {
+    return {
+      kind: "crm",
+      productName,
+      slug,
+      targetUser: "the primary user",
+      promise: "Track leads, notes, follow-ups, and simple pipeline status without enterprise CRM weight.",
+      setupLabel: "Workspace",
+      setupNameLabel: "Workspace name",
+      setupNameValue: `${productName} Consulting`,
+      primaryAction: "Create workspace",
+      secondaryAction: "Preview dashboard",
+      itemSingular: "lead",
+      itemPlural: "leads",
+      itemLabel: "Lead",
+      itemNameLabel: "Name",
+      itemNameValue: "Avery Lee",
+      itemContextLabel: "Next follow-up",
+      itemContextValue: "2026-05-27",
+      itemAction: "Add lead",
+      saveAction: "Save lead",
+      collectionSurface: "lead list",
+      dashboardTitle: "Pipeline dashboard with next actions visible.",
+      emptyState: "Empty state: when no leads exist, keep the first-create CTA prominent.",
+      statusTaxonomy: ["New", "Contacted", "Proposal", "Won", "Lost"],
+      statusExample: "Proposal",
+      metricLabels: ["Active leads", "Due follow-ups", "Proposal value", "Won this month"],
+      metricValues: ["12", "4", "$18k", "3"],
+      modelName: "Lead",
+      storageKeys: [`${slug}.workspace`, `${slug}.leads`],
+      nonGoals: "Enterprise CRM automation, complex analytics, billing, or multi-team administration.",
+    };
+  }
+
+  return {
+    kind: "generic",
+    productName,
+    slug,
+    targetUser: "the primary user",
+    promise: "Turn the core MVP workflow into a clear launch, setup, and dashboard experience.",
+    setupLabel: "Workspace",
+    setupNameLabel: "Workspace name",
+    setupNameValue: `${productName} Team`,
+    primaryAction: "Start setup",
+    secondaryAction: "Preview dashboard",
+    itemSingular: "work item",
+    itemPlural: "work items",
+    itemLabel: "Work item",
+    itemNameLabel: "Item name",
+    itemNameValue: "First workflow",
+    itemContextLabel: "Next action",
+    itemContextValue: "Review progress",
+    itemAction: "Add item",
+    saveAction: "Save item",
+    collectionSurface: "work queue",
+    dashboardTitle: "Dashboard with current work and next actions visible.",
+    emptyState: "Empty state: when no work items exist, keep the first-create CTA prominent.",
+    statusTaxonomy: ["New", "In Progress", "Review", "Done"],
+    statusExample: "In Progress",
+    metricLabels: ["Active items", "Due actions", "In review", "Completed"],
+    metricValues: ["8", "3", "2", "5"],
+    modelName: "WorkItem",
+    storageKeys: [`${slug}.workspace`, `${slug}.items`],
+    nonGoals: "Enterprise workflow automation, advanced analytics, billing, or multi-role administration.",
+  };
+}
+
+module.exports = {
+  extractSourceIdea,
+  inferDomainProfile,
+  normalizeText,
+  slugify,
+};