sdtk-design-kit 0.1.0

package/src/commands/status.js

@@ -0,0 +1,131 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { parseFlags } = require("../lib/args");
+const { describeDesignPaths, resolveProjectPath } = require("../lib/design-paths");
+const { ValidationError } = require("../lib/errors");
+
+const STATUS_FLAG_DEFS = {
+  help: { type: "boolean" },
+  "project-path": { type: "string" },
+};
+
+function cmdStatusHelp() {
+  console.log(`SDTK-DESIGN Status
+
+Usage:
+  sdtk-design status [--project-path <path>]
+
+Example:
+  sdtk-design status
+
+Reports:
+  Complete artifacts.
+  Missing artifacts.
+  Next recommended command.
+
+Safety:
+  Read-only local filesystem inspection.
+  No .sdtk/atlas creation or mutation.
+  No SDTK-WIKI output mutation.
+  No network call, Pro entitlement, or production app code generation.`);
+  return 0;
+}
+
+function artifactPlan(paths) {
+  return [
+    { label: "Design brief", relativePath: "docs/design/DESIGN_BRIEF.md", filePath: paths.designBriefPath, phase: "core" },
+    { label: "Screen map", relativePath: "docs/design/SCREEN_MAP.md", filePath: paths.screenMapPath, phase: "core" },
+    { label: "Landing wireframe", relativePath: "docs/design/wireframes/LANDING.md", filePath: path.join(paths.wireframesPath, "LANDING.md"), phase: "core" },
+    { label: "Onboarding wireframe", relativePath: "docs/design/wireframes/ONBOARDING.md", filePath: path.join(paths.wireframesPath, "ONBOARDING.md"), phase: "core" },
+    { label: "Dashboard wireframe", relativePath: "docs/design/wireframes/DASHBOARD.md", filePath: path.join(paths.wireframesPath, "DASHBOARD.md"), phase: "core" },
+    { label: "Design system", relativePath: "docs/design/DESIGN_SYSTEM.md", filePath: paths.designSystemPath, phase: "core" },
+    { label: "Design handoff", relativePath: "docs/design/DESIGN_HANDOFF.md", filePath: paths.designHandoffPath, phase: "handoff" },
+  ];
+}
+
+function hasReview(paths) {
+  if (!fs.existsSync(paths.reviewsPath) || !fs.statSync(paths.reviewsPath).isDirectory()) {
+    return false;
+  }
+  return fs.readdirSync(paths.reviewsPath).some((name) => /^DESIGN_REVIEW_\d{8}\.md$/.test(name));
+}
+
+function inspectDesignStatus(projectPath) {
+  const resolvedProjectPath = resolveProjectPath(projectPath || process.cwd());
+  if (!fs.existsSync(resolvedProjectPath) || !fs.statSync(resolvedProjectPath).isDirectory()) {
+    throw new ValidationError(`--project-path is not a valid directory: ${resolvedProjectPath}. No project files were changed.`);
+  }
+
+  const paths = describeDesignPaths(resolvedProjectPath);
+  const artifacts = artifactPlan(paths).map((artifact) => ({
+    ...artifact,
+    exists: fs.existsSync(artifact.filePath),
+  }));
+  const reviewExists = hasReview(paths);
+  const coreMissing = artifacts.filter((artifact) => artifact.phase === "core" && !artifact.exists);
+  const handoffMissing = artifacts.find((artifact) => artifact.phase === "handoff" && !artifact.exists);
+
+  let nextCommand = "SDTK-CODE can consume docs/design/DESIGN_HANDOFF.md";
+  if (coreMissing.length > 0) {
+    nextCommand = 'sdtk-design start --idea "<idea>"';
+  } else if (!reviewExists) {
+    nextCommand = "sdtk-design review --artifact docs/design/wireframes/LANDING.md";
+  } else if (handoffMissing) {
+    nextCommand = "sdtk-design handoff";
+  }
+
+  return {
+    projectPath: resolvedProjectPath,
+    artifacts,
+    reviewExists,
+    nextCommand,
+  };
+}
+
+function cmdStatus(args) {
+  const { flags } = parseFlags(args || [], STATUS_FLAG_DEFS);
+  if (flags.help) return cmdStatusHelp();
+
+  const status = inspectDesignStatus(flags["project-path"]);
+  const complete = status.artifacts.filter((artifact) => artifact.exists);
+  const missing = status.artifacts.filter((artifact) => !artifact.exists);
+
+  console.log(`SDTK-DESIGN Status: ${status.projectPath}`);
+  console.log("");
+  console.log("Complete artifacts:");
+  if (complete.length === 0 && !status.reviewExists) {
+    console.log("  - none");
+  } else {
+    for (const artifact of complete) {
+      console.log(`  - ${artifact.relativePath}`);
+    }
+    if (status.reviewExists) {
+      console.log("  - docs/design/reviews/DESIGN_REVIEW_YYYYMMDD.md");
+    }
+  }
+  console.log("");
+  console.log("Missing artifacts:");
+  if (missing.length === 0 && status.reviewExists) {
+    console.log("  - none");
+  } else {
+    for (const artifact of missing) {
+      console.log(`  - ${artifact.relativePath}`);
+    }
+    if (!status.reviewExists) {
+      console.log("  - docs/design/reviews/DESIGN_REVIEW_YYYYMMDD.md");
+    }
+  }
+  console.log("");
+  console.log(`Next recommended command: ${status.nextCommand}`);
+  console.log("No .sdtk/atlas, SDTK-WIKI output, network, or app code was modified.");
+  return 0;
+}
+
+module.exports = {
+  artifactPlan,
+  cmdStatus,
+  cmdStatusHelp,
+  inspectDesignStatus,
+};

package/src/commands/system.js

@@ -0,0 +1,189 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { parseFlags } = require("../lib/args");
+const { describeDesignPaths, resolveProjectPath } = require("../lib/design-paths");
+const { ValidationError } = require("../lib/errors");
+
+const SYSTEM_FLAG_DEFS = {
+  help: { type: "boolean" },
+  "project-path": { type: "string" },
+  force: { type: "boolean" },
+};
+
+function cmdSystemHelp() {
+  console.log(`SDTK-DESIGN System
+
+Usage:
+  sdtk-design system [--project-path <path>] [--force]
+
+Example:
+  sdtk-design system
+
+Reads:
+  docs/design/DESIGN_BRIEF.md
+  docs/design/SCREEN_MAP.md
+
+Creates:
+  docs/design/DESIGN_SYSTEM.md
+
+Safety:
+  Local files only.
+  Existing DESIGN_SYSTEM.md is not overwritten unless --force is explicit.
+  No .sdtk/atlas creation or mutation.
+  No SDTK-WIKI output mutation.
+  No network call, Pro entitlement, or production app code generation.`);
+  return 0;
+}
+
+function includesAny(text, terms) {
+  const value = text.toLowerCase();
+  return terms.some((term) => value.includes(term));
+}
+
+function systemContent(briefContent, screenMapContent) {
+  const source = `${briefContent}\n${screenMapContent}`;
+  const isCrm = includesAny(source, ["crm", "lead", "follow-up", "pipeline"]);
+  const primaryAction = isCrm ? "Add first lead" : "Start first workflow";
+  const toneObject = isCrm ? "lead, follow-up, note, and pipeline" : "record, task, status, and next action";
+
+  return [
+    "# Design System",
+    "",
+    "## Product Direction",
+    "",
+    "- Use a calm, work-focused interface that helps a solo founder move from idea to repeated MVP workflow.",
+    "- Favor clarity, scannability, and obvious next actions over decorative marketing composition.",
+    `- Primary repeated action: ${primaryAction}.`,
+    "",
+    "## Typography",
+    "",
+    "- Font stack: system UI, Segoe UI, Roboto, Helvetica, Arial, sans-serif.",
+    "- Page title: 28px, 36px line-height, semibold.",
+    "- Section heading: 18px, 26px line-height, semibold.",
+    "- Body text: 15px, 22px line-height, regular.",
+    "- Label text: 13px, 18px line-height, medium.",
+    "- Do not scale font size with viewport width; keep letter spacing at 0.",
+    "",
+    "## Color Tokens",
+    "",
+    "- `color-bg`: #F7F8FA for the application background.",
+    "- `color-surface`: #FFFFFF for panels, forms, and lists.",
+    "- `color-text`: #1F2933 for primary text.",
+    "- `color-muted`: #667085 for secondary text.",
+    "- `color-primary`: #2563EB for the main CTA and selected states.",
+    "- `color-success`: #0F8A5F for confirmed progress.",
+    "- `color-warning`: #B7791F for attention without blocking.",
+    "- `color-danger`: #B42318 for destructive or failed states.",
+    "- `color-border`: #D9DEE7 for quiet dividers and input borders.",
+    "",
+    "## Spacing",
+    "",
+    "- Base grid: 4px.",
+    "- Tight gap: 8px for label-control and icon-text pairs.",
+    "- Standard gap: 16px for form fields and list rows.",
+    "- Section gap: 24px for screen regions.",
+    "- Page padding: 20px mobile, 32px desktop.",
+    "- Keep fixed-format controls stable with explicit min-height and predictable grid tracks.",
+    "",
+    "## Button Style",
+    "",
+    "- Primary button: filled `color-primary`, white label, 40px minimum height, 8px radius.",
+    "- Secondary button: white surface, `color-border` outline, primary text.",
+    "- Icon buttons: square 36px control with tooltip when the icon is not self-evident.",
+    "- Disabled state: 45% opacity with no hover elevation.",
+    "- CTA copy should use verbs tied to the workflow, such as Add, Save, Continue, or Review.",
+    "",
+    "## Card Style",
+    "",
+    "- Use cards only for repeated records or genuinely framed tool surfaces.",
+    "- Radius: 8px maximum.",
+    "- Border: 1px solid `color-border`; avoid heavy shadows.",
+    "- Card content order: status, title, next action, supporting metadata.",
+    "- Avoid nested cards and decorative gradient backgrounds.",
+    "",
+    "## Form Style",
+    "",
+    "- Place labels above inputs with concise helper text only when it reduces uncertainty.",
+    "- Required fields should be obvious before submit.",
+    "- Inline errors must identify the field and preserve entered values.",
+    "- Prefer segmented controls or toggles for short option sets.",
+    "- Forms should ask for the minimum needed before the first useful action.",
+    "",
+    "## Tone",
+    "",
+    `- Use practical language around ${toneObject}; avoid enterprise jargon.`,
+    "- Keep copy short, direct, and action-oriented.",
+    "- Empty states should explain what is missing and offer one next action.",
+    "- Success copy should confirm progress without celebration-heavy language.",
+    "",
+    "## Accessibility Baseline",
+    "",
+    "- Maintain visible keyboard focus for all interactive controls.",
+    "- Use 4.5:1 contrast for body text and 3:1 for large text and essential UI boundaries.",
+    "- Do not rely on color alone for status; pair status color with text or icon labels.",
+    "- All form inputs require labels; all icon-only controls require accessible names.",
+    "- Mobile targets should be at least 44px by 44px where practical.",
+    "- Error and success states must be announced through text in the layout.",
+    "",
+    "## Boundaries",
+    "",
+    "- This design system is guidance for SDTK-DESIGN artifacts, not generated production CSS.",
+    "- No Figma, Lovable, v0, or full app-builder replacement behavior is claimed.",
+    "- No network call, Pro entitlement, `.sdtk/atlas`, or SDTK-WIKI output is required.",
+    "",
+  ].join("\n");
+}
+
+function runDesignSystem({ projectPath, force = false }) {
+  const resolvedProjectPath = resolveProjectPath(projectPath || process.cwd());
+  if (!fs.existsSync(resolvedProjectPath) || !fs.statSync(resolvedProjectPath).isDirectory()) {
+    throw new ValidationError(`--project-path is not a valid directory: ${resolvedProjectPath}. No project files were changed.`);
+  }
+
+  const paths = describeDesignPaths(resolvedProjectPath);
+  if (!fs.existsSync(paths.designBriefPath)) {
+    throw new ValidationError("Missing docs/design/DESIGN_BRIEF.md. Run sdtk-design brief --idea \"<idea>\" first. No project files were changed.");
+  }
+  if (!fs.existsSync(paths.screenMapPath)) {
+    throw new ValidationError("Missing docs/design/SCREEN_MAP.md. Run sdtk-design screens first. No project files were changed.");
+  }
+  if (fs.existsSync(paths.designSystemPath) && !force) {
+    throw new ValidationError("docs/design/DESIGN_SYSTEM.md already exists. Re-run with --force to replace this managed design system.");
+  }
+
+  const briefContent = fs.readFileSync(paths.designBriefPath, "utf-8");
+  const screenMapContent = fs.readFileSync(paths.screenMapPath, "utf-8");
+  fs.mkdirSync(path.dirname(paths.designSystemPath), { recursive: true });
+  fs.writeFileSync(paths.designSystemPath, systemContent(briefContent, screenMapContent), "utf-8");
+
+  return {
+    projectPath: resolvedProjectPath,
+    relativeDesignSystemPath: "docs/design/DESIGN_SYSTEM.md",
+    forced: Boolean(force),
+  };
+}
+
+function cmdSystem(args) {
+  const { flags } = parseFlags(args || [], SYSTEM_FLAG_DEFS);
+  if (flags.help) return cmdSystemHelp();
+
+  const result = runDesignSystem({
+    projectPath: flags["project-path"],
+    force: Boolean(flags.force),
+  });
+
+  console.log(`[design] Wrote ${result.relativeDesignSystemPath}: ${result.projectPath}`);
+  console.log(`[design] Overwrite: ${result.forced ? "enabled by --force" : "not needed"}`);
+  console.log("[design] No .sdtk/atlas, SDTK-WIKI output, source files, network, or app code was modified.");
+  console.log("[design] Next: sdtk-design handoff");
+  return 0;
+}
+
+module.exports = {
+  cmdSystem,
+  cmdSystemHelp,
+  runDesignSystem,
+  systemContent,
+};

package/src/commands/wireframe.js

@@ -0,0 +1,245 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { parseFlags } = require("../lib/args");
+const { describeDesignPaths, resolveProjectPath } = require("../lib/design-paths");
+const { ValidationError } = require("../lib/errors");
+
+const WIREFRAME_FLAG_DEFS = {
+  help: { type: "boolean" },
+  screen: { type: "string" },
+  "project-path": { type: "string" },
+  force: { type: "boolean" },
+};
+
+const SCREEN_CONFIGS = {
+  landing: {
+    id: "LANDING",
+    title: "Landing",
+    fileName: "LANDING.md",
+    intent: "Convert a visitor from product promise to the first setup step.",
+    cta: "Add first lead",
+    sections: [
+      "Header with product name, concise positioning, and one primary CTA.",
+      "Hero promise with target user, pain point, MVP promise, and CTA.",
+      "Workflow preview showing lead capture, follow-up, notes, and pipeline visibility.",
+      "Trust strip with simple benefits and clear boundary against enterprise complexity.",
+    ],
+    components: ["Header", "Hero copy block", "Primary CTA button", "Workflow preview list", "Benefit bullets"],
+    mobile: "Stack hero copy, CTA, and preview vertically. Keep the CTA visible above the first scroll.",
+    copy: "Use direct solo-founder language. Lead with the outcome, then reduce fear of enterprise CRM complexity.",
+  },
+  onboarding: {
+    id: "ONBOARDING",
+    title: "Onboarding",
+    fileName: "ONBOARDING.md",
+    intent: "Capture the minimum setup needed before the first repeated workflow action.",
+    cta: "Create workspace",
+    sections: [
+      "Progress header with one short setup step.",
+      "Workspace basics form with required label and optional sample data choice.",
+      "First lead prompt that lets the user continue directly into lead capture.",
+      "Footer actions for continue and skip non-essential setup.",
+    ],
+    components: ["Progress indicator", "Text input", "Segmented sample-data control", "Primary CTA button", "Inline validation message"],
+    mobile: "Use a single-column form with large touch targets and persistent continue action after required fields.",
+    copy: "Keep labels plain and reassuring. Explain why each required field matters.",
+  },
+  dashboard: {
+    id: "DASHBOARD",
+    title: "Dashboard",
+    fileName: "DASHBOARD.md",
+    intent: "Help the user scan active work and choose the next follow-up action.",
+    cta: "Add first lead",
+    sections: [
+      "Top summary row with active leads, due follow-ups, and simple revenue pipeline status.",
+      "Priority list of leads with status, next action date, and latest note.",
+      "Inline quick-add action for a new lead or note.",
+      "Empty-state panel that routes back to the first lead CTA.",
+    ],
+    components: ["Summary counters", "Lead list", "Status pill", "Quick-add button", "Empty-state panel", "Recoverable error alert"],
+    mobile: "Collapse summary counters into two columns, then show lead cards with next action first.",
+    copy: "Use action-first labels such as Due today, Add note, and Move stage. Avoid enterprise CRM jargon.",
+  },
+};
+
+function cmdWireframeHelp() {
+  console.log(`SDTK-DESIGN Wireframe
+
+Usage:
+  sdtk-design wireframe --screen landing [--project-path <path>] [--force]
+  sdtk-design wireframe --screen all [--project-path <path>] [--force]
+
+Examples:
+  sdtk-design wireframe --screen landing
+  sdtk-design wireframe --screen all
+
+Reads:
+  docs/design/SCREEN_MAP.md
+
+Creates:
+  docs/design/wireframes/LANDING.md
+  docs/design/wireframes/ONBOARDING.md
+  docs/design/wireframes/DASHBOARD.md
+
+Safety:
+  Local files only.
+  Existing wireframe files are not overwritten unless --force is explicit.
+  No .sdtk/atlas creation or mutation.
+  No SDTK-WIKI output mutation.
+  No network call, Pro entitlement, or production app code generation.`);
+  return 0;
+}
+
+function normalizeScreenName(screen) {
+  return String(screen || "").trim().toLowerCase();
+}
+
+function screenTargets(screen) {
+  const normalized = normalizeScreenName(screen);
+  if (!normalized) {
+    throw new ValidationError('Missing required --screen "<landing|onboarding|dashboard|all>". No project files were changed.');
+  }
+  if (normalized === "all") {
+    return ["landing", "onboarding", "dashboard"];
+  }
+  if (!SCREEN_CONFIGS[normalized]) {
+    throw new ValidationError(`Unsupported --screen "${screen}". Use landing, onboarding, dashboard, or all. No project files were changed.`);
+  }
+  return [normalized];
+}
+
+function extractScreenMapLine(screenMapContent, screenId, label) {
+  const lines = screenMapContent.split(/\r?\n/);
+  const start = lines.findIndex((line) => line.trim().startsWith(`### ${screenId} `));
+  if (start < 0) return "";
+  for (let index = start + 1; index < lines.length; index += 1) {
+    const line = lines[index].trim();
+    if (line.startsWith("### ")) return "";
+    if (line.startsWith(`- ${label}:`)) {
+      return line.slice(`- ${label}:`.length).trim();
+    }
+  }
+  return "";
+}
+
+function wireframeContent(screenKey, screenMapContent) {
+  const config = SCREEN_CONFIGS[screenKey];
+  const purpose = extractScreenMapLine(screenMapContent, config.id, "Purpose") || config.intent;
+  const dataNeeded = extractScreenMapLine(screenMapContent, config.id, "Data needed") || "Primary workflow data from the screen map.";
+  const emptyState = extractScreenMapLine(screenMapContent, config.id, "Empty state") || "Guide the user to the first meaningful action.";
+  const successState = extractScreenMapLine(screenMapContent, config.id, "Success state") || "User completes the screen's primary action.";
+  const errorState = extractScreenMapLine(screenMapContent, config.id, "Error state") || "Show a recoverable error and preserve user input.";
+
+  return [
+    `# ${config.id} Wireframe`,
+    "",
+    "## Source Screen",
+    "",
+    `- Screen: ${config.title}`,
+    `- Purpose: ${purpose}`,
+    `- Data needed: ${dataNeeded}`,
+    "",
+    "## Layout Sections",
+    "",
+    ...config.sections.map((section) => `- ${section}`),
+    "",
+    "## Components",
+    "",
+    ...config.components.map((component) => `- ${component}`),
+    "",
+    "## Primary CTA",
+    "",
+    `- Label: ${config.cta}`,
+    "- Placement: first viewport and repeated near the workflow completion point.",
+    "- Behavior: advances to the next MVP step without opening external tools.",
+    "",
+    "## State Handling",
+    "",
+    `- Empty: ${emptyState}`,
+    `- Success: ${successState}`,
+    `- Error: ${errorState}`,
+    "",
+    "## Mobile Notes",
+    "",
+    `- ${config.mobile}`,
+    "- Avoid side-by-side dependencies; each section must scan as a single column on narrow screens.",
+    "",
+    "## Copy Direction",
+    "",
+    `- ${config.copy}`,
+    "- Keep copy concrete, short, and tied to the user action on the current screen.",
+    "",
+    "## Acceptance Criteria",
+    "",
+    "- The screen has one visually dominant primary CTA.",
+    "- Required data, empty, success, and error states are represented in the layout.",
+    "- Mobile layout preserves the CTA and next action without horizontal scrolling.",
+    "- The wireframe does not specify production app code, network integrations, or entitlement gates.",
+    "- No Figma, Lovable, v0, or full app-builder replacement behavior is claimed.",
+    "",
+  ].join("\n");
+}
+
+function runDesignWireframe({ screen, projectPath, force = false }) {
+  const targets = screenTargets(screen);
+  const resolvedProjectPath = resolveProjectPath(projectPath || process.cwd());
+  if (!fs.existsSync(resolvedProjectPath) || !fs.statSync(resolvedProjectPath).isDirectory()) {
+    throw new ValidationError(`--project-path is not a valid directory: ${resolvedProjectPath}. No project files were changed.`);
+  }
+
+  const paths = describeDesignPaths(resolvedProjectPath);
+  if (!fs.existsSync(paths.screenMapPath)) {
+    throw new ValidationError("Missing docs/design/SCREEN_MAP.md. Run sdtk-design screens first. No project files were changed.");
+  }
+
+  const outputTargets = targets.map((target) => ({
+    screenKey: target,
+    filePath: path.join(paths.wireframesPath, SCREEN_CONFIGS[target].fileName),
+    relativePath: `docs/design/wireframes/${SCREEN_CONFIGS[target].fileName}`,
+  }));
+  const existing = outputTargets.filter((target) => fs.existsSync(target.filePath));
+  if (existing.length > 0 && !force) {
+    const files = existing.map((target) => target.relativePath).join(", ");
+    throw new ValidationError(`${files} already exists. Re-run with --force to replace managed wireframe output.`);
+  }
+
+  const screenMapContent = fs.readFileSync(paths.screenMapPath, "utf-8");
+  fs.mkdirSync(paths.wireframesPath, { recursive: true });
+  for (const target of outputTargets) {
+    fs.writeFileSync(target.filePath, wireframeContent(target.screenKey, screenMapContent), "utf-8");
+  }
+
+  return {
+    projectPath: resolvedProjectPath,
+    written: outputTargets.map((target) => target.relativePath),
+    forced: Boolean(force),
+  };
+}
+
+function cmdWireframe(args) {
+  const { flags } = parseFlags(args || [], WIREFRAME_FLAG_DEFS);
+  if (flags.help) return cmdWireframeHelp();
+
+  const result = runDesignWireframe({
+    screen: flags.screen,
+    projectPath: flags["project-path"],
+    force: Boolean(flags.force),
+  });
+
+  console.log(`[design] Wrote wireframes: ${result.written.join(", ")}`);
+  console.log(`[design] Project: ${result.projectPath}`);
+  console.log(`[design] Overwrite: ${result.forced ? "enabled by --force" : "not needed"}`);
+  console.log("[design] No .sdtk/atlas, SDTK-WIKI output, source files, network, or app code was modified.");
+  console.log("[design] Next: sdtk-design system");
+  return 0;
+}
+
+module.exports = {
+  SCREEN_CONFIGS,
+  cmdWireframe,
+  cmdWireframeHelp,
+  runDesignWireframe,
+  wireframeContent,
+};

package/src/index.js

@@ -0,0 +1,88 @@
+"use strict";
+
+const { cmdBrief } = require("./commands/brief");
+const { cmdHandoff } = require("./commands/handoff");
+const { cmdHelp } = require("./commands/help");
+const { cmdInit } = require("./commands/init");
+const { cmdReview } = require("./commands/review");
+const { cmdScreens } = require("./commands/screens");
+const { cmdStart } = require("./commands/start");
+const { cmdStatus } = require("./commands/status");
+const { cmdSystem } = require("./commands/system");
+const { cmdWireframe } = require("./commands/wireframe");
+const { ValidationError } = require("./lib/errors");
+
+const DEFERRED_COMMANDS = new Map([]);
+
+function getVersion() {
+  const pkg = require("../package.json");
+  return pkg.version;
+}
+
+function parseCommand(argv) {
+  if (!argv || argv.length === 0) {
+    return { command: "help", args: [] };
+  }
+
+  const [first, ...rest] = argv;
+  if (first === "-h" || first === "--help") {
+    return { command: "help", args: [] };
+  }
+  if (first === "-v" || first === "--version") {
+    return { command: "version", args: [] };
+  }
+
+  return { command: first, args: rest };
+}
+
+async function run(argv) {
+  const { command, args } = parseCommand(argv);
+
+  if (command === "help") {
+    return cmdHelp();
+  }
+  if (command === "version") {
+    console.log(`sdtk-design-kit ${getVersion()}`);
+    return 0;
+  }
+  if (command === "init") {
+    return cmdInit(args);
+  }
+  if (command === "brief") {
+    return cmdBrief(args);
+  }
+  if (command === "screens") {
+    return cmdScreens(args);
+  }
+  if (command === "wireframe") {
+    return cmdWireframe(args);
+  }
+  if (command === "system") {
+    return cmdSystem(args);
+  }
+  if (command === "handoff") {
+    return cmdHandoff(args);
+  }
+  if (command === "review") {
+    return cmdReview(args);
+  }
+  if (command === "start") {
+    return cmdStart(args);
+  }
+  if (command === "status") {
+    return cmdStatus(args);
+  }
+  if (DEFERRED_COMMANDS.has(command)) {
+    throw new ValidationError(
+      `Command "${command}" is planned for ${DEFERRED_COMMANDS.get(command)} and is not implemented yet. Run "sdtk-design --help" for the current Foundation Beta surface.`
+    );
+  }
+
+  throw new ValidationError(`Unknown command: "${command}". Run "sdtk-design --help" for available commands.`);
+}
+
+module.exports = {
+  DEFERRED_COMMANDS,
+  parseCommand,
+  run,
+};