sdtk-design-kit 0.1.0

package/README.md

@@ -0,0 +1,123 @@
+# SDTK-DESIGN Kit
+
+`sdtk-design-kit` is the standalone SDTK-DESIGN Foundation Beta package.
+
+SDTK-DESIGN is a local-first MVP design planner and reviewer for solo founders. It turns a rough MVP idea into reviewable design artifacts and a deterministic handoff for SDTK-CODE.
+
+It is not a Figma clone, Lovable clone, v0 clone, full app builder, or production code generator.
+
+## Beginner Flow
+
+Use this five-command flow for a clean project:
+
+```powershell
+sdtk-design init
+sdtk-design start --idea "I want to build a lightweight CRM for solo consultants to track leads, follow-ups, notes, and simple revenue pipeline without using a complex enterprise CRM."
+sdtk-design review --artifact docs/design/wireframes/LANDING.md
+sdtk-design handoff
+sdtk-design status
+```
+
+What each command does:
+
+- `init`: creates the local design workspace.
+- `start`: creates the design brief, screen map, required wireframes, and design system.
+- `review`: reviews a local markdown design artifact.
+- `handoff`: converts the generated design package into SDTK-CODE handoff guidance.
+- `status`: reports complete artifacts, missing artifacts, and the next recommended command.
+
+## Available Commands
+
+```powershell
+sdtk-design --help
+sdtk-design --version
+sdtk-design init [--project-path <path>] [--force] [--no-state]
+sdtk-design start --idea "<idea>" [--project-path <path>] [--force]
+sdtk-design brief --idea "<idea>" [--project-path <path>] [--force]
+sdtk-design screens [--project-path <path>] [--force]
+sdtk-design wireframe --screen landing [--project-path <path>] [--force]
+sdtk-design wireframe --screen all [--project-path <path>] [--force]
+sdtk-design system [--project-path <path>] [--force]
+sdtk-design review --artifact docs/design/wireframes/LANDING.md [--project-path <path>] [--force]
+sdtk-design handoff [--project-path <path>] [--force]
+sdtk-design status [--project-path <path>]
+```
+
+## Generated Artifacts
+
+Human-facing output is written under `docs/design/`:
+
+```text
+docs/design/
+  README.md
+  DESIGN_BRIEF.md
+  SCREEN_MAP.md
+  DESIGN_SYSTEM.md
+  DESIGN_HANDOFF.md
+  wireframes/
+    LANDING.md
+    ONBOARDING.md
+    DASHBOARD.md
+  reviews/
+    DESIGN_REVIEW_YYYYMMDD.md
+```
+
+Internal state may live under `.sdtk/design/`. SDTK-DESIGN must not create or mutate `.sdtk/atlas`.
+
+## Command Details
+
+### `init`
+
+Creates `docs/design/`, `docs/design/wireframes/`, `docs/design/reviews/`, `docs/design/README.md`, and `.sdtk/design/manifest.json`.
+
+Existing managed init files are skipped by default. Use `--force` only when you explicitly want to refresh managed init files. Use `--no-state` to skip `.sdtk/design`.
+
+### `start`
+
+Runs:
+
+```text
+brief -> screens -> wireframe --screen all -> system
+```
+
+This is the beginner facade for the core design package. It does not run review or handoff. Existing managed core outputs are not overwritten unless `--force` is explicit.
+
+### `review`
+
+Reviews a local markdown artifact, for example:
+
+```powershell
+sdtk-design review --artifact docs/design/wireframes/LANDING.md
+```
+
+The review report is written to `docs/design/reviews/DESIGN_REVIEW_YYYYMMDD.md`.
+
+Current review support is local markdown artifact review only. No URL, browser, screenshot, vision, or DOM review is implemented in Foundation Beta.
+
+### `handoff`
+
+Reads the generated brief, screen map, required wireframes, and design system, then writes `docs/design/DESIGN_HANDOFF.md`.
+
+The handoff is planning input for SDTK-CODE. It includes screen-to-component mapping, screen-to-user-story mapping, design decisions, implementation notes, acceptance criteria, and a readiness verdict. It does not generate production app code.
+
+### `status`
+
+Read-only command. It reports complete artifacts, missing artifacts, and the next recommended command.
+
+## Non-Goals And Deferred Features
+
+Foundation Beta does not provide:
+
+- Figma, Lovable, v0, or full app-builder replacement behavior.
+- Production app code generation.
+- URL, browser, screenshot, vision, or DOM review.
+- Network calls by default.
+- Pro entitlement gates.
+- `.sdtk/atlas` creation or mutation.
+- SDTK-WIKI output mutation.
+- Landing-site updates.
+- npm publish or maintainer packaging checks without separate maintainer approval.
+
+## SDTK-CODE Handoff
+
+After `sdtk-design handoff`, pass `docs/design/DESIGN_HANDOFF.md` to SDTK-CODE as implementation planning input. SDTK-CODE should still plan, implement, and verify code changes separately.

package/bin/sdtk-design.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+
+"use strict";
+
+const { run } = require("../src/index");
+
+run(process.argv.slice(2))
+  .then((exitCode) => {
+    process.exitCode = Number.isInteger(exitCode) ? exitCode : 0;
+  })
+  .catch((error) => {
+    console.error(`sdtk-design: ${error.message}`);
+    process.exitCode = typeof error.exitCode === "number" ? error.exitCode : 4;
+  });

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "sdtk-design-kit",
+  "version": "0.1.0",
+  "description": "Local-first MVP design planner and reviewer for SDTK workspaces.",
+  "bin": {
+    "sdtk-design": "bin/sdtk-design.js"
+  },
+  "main": "src/index.js",
+  "type": "commonjs",
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "powershell -ExecutionPolicy Bypass -Command \"$ErrorActionPreference = 'Stop'; Set-Location '..\\..\\..\\..'; python -m pytest tests/test_sdtk_design_cli.py -q\"",
+    "pack:smoke": "npm pack --dry-run"
+  },
+  "engines": {
+    "node": ">=18.13.0"
+  },
+  "keywords": [
+    "sdtk-design",
+    "design",
+    "mvp",
+    "wireframe",
+    "cli",
+    "toolkit"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codexsdtk/sdtk-toolkit.git",
+    "directory": "products/sdtk-design/distribution/sdtk-design-kit"
+  },
+  "homepage": "https://github.com/codexsdtk/sdtk-toolkit/tree/main/products/sdtk-design/distribution/sdtk-design-kit",
+  "bugs": {
+    "url": "https://github.com/codexsdtk/sdtk-toolkit/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/commands/brief.js

@@ -0,0 +1,198 @@
+"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 { runDesignInit } = require("./init");
+
+const BRIEF_FLAG_DEFS = {
+  help: { type: "boolean" },
+  idea: { type: "string" },
+  "project-path": { type: "string" },
+  force: { type: "boolean" },
+};
+
+function cmdBriefHelp() {
+  console.log(`SDTK-DESIGN Brief
+
+Usage:
+  sdtk-design brief --idea "<rough MVP idea>" [--project-path <path>] [--force]
+
+Example:
+  sdtk-design brief --idea "I want to build a lightweight CRM for solo consultants."
+
+Creates:
+  docs/design/DESIGN_BRIEF.md
+
+Safety:
+  Local files only.
+  Existing DESIGN_BRIEF.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 normalizeIdea(idea) {
+  return String(idea || "").replace(/\s+/g, " ").trim();
+}
+
+function extractFirstMatch(text, pattern) {
+  const match = text.match(pattern);
+  return match ? match[1].trim().replace(/[.]+$/, "") : "";
+}
+
+function sentenceCase(value) {
+  const clean = normalizeIdea(value);
+  if (!clean) return clean;
+  return clean.charAt(0).toUpperCase() + clean.slice(1);
+}
+
+function inferBriefFields(idea) {
+  const lowerIdea = idea.toLowerCase();
+  const targetUser = extractFirstMatch(idea, /\bfor\s+(.+?)\s+to\s+/i) || "solo founders validating a focused MVP";
+  const outcome = extractFirstMatch(idea, /\bto\s+(.+?)(?:\s+without\b|$)/i) || "complete the primary MVP workflow with less friction";
+  const constraint = extractFirstMatch(idea, /\bwithout\s+(.+?)$/i);
+  const isCrm = lowerIdea.includes("crm") || lowerIdea.includes("lead") || lowerIdea.includes("pipeline");
+
+  const productType = isCrm ? "lightweight CRM" : "focused MVP workspace";
+  const primaryCta = isCrm ? "Add first lead" : "Start first workflow";
+  const successMetric = isCrm
+    ? "A solo consultant can add a lead, schedule a follow-up, record a note, and see the simple pipeline status in under 5 minutes."
+    : "A first-time user can complete the primary workflow and understand the next action in under 5 minutes.";
+
+  const painPoint = constraint
+    ? `${sentenceCase(targetUser)} need to ${outcome}, but ${constraint} creates too much friction for the first version.`
+    : `${sentenceCase(targetUser)} need to ${outcome}, but the current alternative is too slow, scattered, or hard to adopt for an MVP.`;
+
+  const nonGoals = isCrm
+    ? [
+        "Enterprise CRM automation, complex custom fields, territory management, and multi-team permissions.",
+        "Heavy analytics, forecasting, billing, marketing automation, or third-party CRM synchronization.",
+        "A production app implementation or database schema generated by SDTK-DESIGN.",
+      ]
+    : [
+        "Enterprise workflow automation, broad admin settings, and deep customization.",
+        "Advanced analytics, billing, integrations, or multi-role governance beyond the MVP path.",
+        "A production app implementation or database schema generated by SDTK-DESIGN.",
+      ];
+
+  return {
+    targetUser,
+    outcome,
+    productType,
+    primaryCta,
+    painPoint,
+    successMetric,
+    nonGoals,
+  };
+}
+
+function designBriefContent(idea) {
+  const fields = inferBriefFields(idea);
+  return [
+    "# Design Brief",
+    "",
+    "## Source Idea",
+    "",
+    idea,
+    "",
+    "## Target User",
+    "",
+    `- ${sentenceCase(fields.targetUser)}.`,
+    "",
+    "## Problem / Pain Point",
+    "",
+    `- ${fields.painPoint}`,
+    "",
+    "## MVP Promise",
+    "",
+    `- A ${fields.productType} that helps ${fields.targetUser} ${fields.outcome} without the weight of a complex tool.`,
+    "",
+    "## Primary CTA",
+    "",
+    `- ${fields.primaryCta}`,
+    "",
+    "## Non-Goals",
+    "",
+    ...fields.nonGoals.map((item) => `- ${item}`),
+    "",
+    "## Success Metric",
+    "",
+    `- ${fields.successMetric}`,
+    "",
+    "## Assumptions",
+    "",
+    "- The first release is for one primary user role and one primary workflow.",
+    "- The MVP should favor fast capture, clear next action, and readable status over deep configuration.",
+    "- Human-facing design artifacts stay under `docs/design`; internal state may stay under `.sdtk/design`.",
+    "",
+    "## Open Questions",
+    "",
+    "- What is the single highest-value action the user must complete on day one?",
+    "- Which information is required versus optional during first-use setup?",
+    "- What empty state copy should guide a user before any records exist?",
+    "- Which manual workarounds are acceptable for the Foundation Beta MVP?",
+    "",
+    "## Next Design Steps",
+    "",
+    "- Run `sdtk-design screens` to create the screen map.",
+    "- Run `sdtk-design wireframe --screen landing` after the screen map exists.",
+    "",
+  ].join("\n");
+}
+
+function runDesignBrief({ idea, projectPath, force = false }) {
+  const normalizedIdea = normalizeIdea(idea);
+  if (!normalizedIdea) {
+    throw new ValidationError('Missing required --idea "<rough MVP idea>". No project files were changed.');
+  }
+
+  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) && !force) {
+    throw new ValidationError("docs/design/DESIGN_BRIEF.md already exists. Re-run with --force to replace this managed brief.");
+  }
+
+  runDesignInit({ projectPath: resolvedProjectPath, force: false, state: true });
+  fs.mkdirSync(path.dirname(paths.designBriefPath), { recursive: true });
+  fs.writeFileSync(paths.designBriefPath, designBriefContent(normalizedIdea), "utf-8");
+
+  return {
+    projectPath: resolvedProjectPath,
+    briefPath: paths.designBriefPath,
+    relativeBriefPath: "docs/design/DESIGN_BRIEF.md",
+    forced: Boolean(force),
+  };
+}
+
+function cmdBrief(args) {
+  const { flags } = parseFlags(args || [], BRIEF_FLAG_DEFS);
+  if (flags.help) return cmdBriefHelp();
+
+  const result = runDesignBrief({
+    idea: flags.idea,
+    projectPath: flags["project-path"],
+    force: Boolean(flags.force),
+  });
+
+  console.log(`[design] Wrote ${result.relativeBriefPath}: ${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 screens");
+  return 0;
+}
+
+module.exports = {
+  cmdBrief,
+  cmdBriefHelp,
+  designBriefContent,
+  inferBriefFields,
+  runDesignBrief,
+};

package/src/commands/handoff.js

@@ -0,0 +1,173 @@
+"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 HANDOFF_FLAG_DEFS = {
+  help: { type: "boolean" },
+  "project-path": { type: "string" },
+  force: { type: "boolean" },
+};
+
+const REQUIRED_WIREFRAMES = ["LANDING.md", "ONBOARDING.md", "DASHBOARD.md"];
+
+function cmdHandoffHelp() {
+  console.log(`SDTK-DESIGN Handoff
+
+Usage:
+  sdtk-design handoff [--project-path <path>] [--force]
+
+Example:
+  sdtk-design handoff
+
+Reads:
+  docs/design/DESIGN_BRIEF.md
+  docs/design/SCREEN_MAP.md
+  docs/design/wireframes/LANDING.md
+  docs/design/wireframes/ONBOARDING.md
+  docs/design/wireframes/DASHBOARD.md
+  docs/design/DESIGN_SYSTEM.md
+
+Creates:
+  docs/design/DESIGN_HANDOFF.md
+
+Safety:
+  Local files only.
+  Existing DESIGN_HANDOFF.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 requiredArtifacts(paths) {
+  return [
+    { label: "Design brief", relativePath: "docs/design/DESIGN_BRIEF.md", filePath: paths.designBriefPath },
+    { label: "Screen map", relativePath: "docs/design/SCREEN_MAP.md", filePath: paths.screenMapPath },
+    { label: "Design system", relativePath: "docs/design/DESIGN_SYSTEM.md", filePath: paths.designSystemPath },
+    ...REQUIRED_WIREFRAMES.map((fileName) => ({
+      label: `${fileName.replace(".md", "")} wireframe`,
+      relativePath: `docs/design/wireframes/${fileName}`,
+      filePath: path.join(paths.wireframesPath, fileName),
+    })),
+  ];
+}
+
+function handoffContent() {
+  return [
+    "# Design Handoff",
+    "",
+    "## Readiness Verdict",
+    "",
+    "- Verdict: READY_FOR_SDTK_CODE",
+    "- Rationale: Required Phase A design artifacts exist and provide enough screen, component, state, and design-system context for implementation planning.",
+    "",
+    "## Source Artifacts",
+    "",
+    "- `docs/design/DESIGN_BRIEF.md`",
+    "- `docs/design/SCREEN_MAP.md`",
+    "- `docs/design/wireframes/LANDING.md`",
+    "- `docs/design/wireframes/ONBOARDING.md`",
+    "- `docs/design/wireframes/DASHBOARD.md`",
+    "- `docs/design/DESIGN_SYSTEM.md`",
+    "",
+    "## Screen-To-Component Mapping",
+    "",
+    "| Screen | Design artifact | Component direction |",
+    "|---|---|---|",
+    "| Landing | `docs/design/wireframes/LANDING.md` | Header, hero copy, primary CTA, workflow preview, benefit bullets |",
+    "| Onboarding | `docs/design/wireframes/ONBOARDING.md` | Progress indicator, setup form, segmented sample-data control, inline validation, continue CTA |",
+    "| Dashboard | `docs/design/wireframes/DASHBOARD.md` | Summary counters, lead list, status pill, quick-add action, empty-state panel, recoverable error alert |",
+    "",
+    "## Screen-To-User-Story Mapping",
+    "",
+    "| Screen | User story | Acceptance signal |",
+    "|---|---|---|",
+    "| Landing | As a solo consultant, I want to understand the lightweight CRM promise so I can decide whether to start. | Primary CTA is visible and routes to onboarding. |",
+    "| Onboarding | As a new user, I want a short setup path so I can create my first lead without enterprise configuration. | Required fields are clear, validation is inline, and entered values are preserved on error. |",
+    "| Dashboard | As a solo consultant, I want to see active leads and follow-ups so I can choose my next action. | Leads, next actions, notes, and simple pipeline status are scannable with empty and error states. |",
+    "",
+    "## Design Decisions",
+    "",
+    "- Keep the MVP to three core screens: Landing, Onboarding, and Dashboard.",
+    "- Optimize for repeated action and scan speed over decorative presentation.",
+    "- Use a restrained operational design system with stable controls, clear form states, and accessible status language.",
+    "- Preserve `docs/design` as the human-facing design output boundary.",
+    "",
+    "## Implementation Notes For SDTK-CODE",
+    "",
+    "- Treat the markdown artifacts as planning input, not generated production code.",
+    "- Implement screens in this order: Landing, Onboarding, Dashboard.",
+    "- Keep user data capture minimal until the first useful workflow is complete.",
+    "- Preserve empty, success, and error states from the screen map and wireframes.",
+    "- Apply typography, color, spacing, button, card, form, tone, and accessibility rules from `DESIGN_SYSTEM.md`.",
+    "",
+    "## Acceptance Criteria",
+    "",
+    "- Landing renders the product promise, workflow preview, and a single dominant primary CTA.",
+    "- Onboarding captures only required setup data and keeps validation inline.",
+    "- Dashboard shows active work, next action, simple pipeline status, empty state, and recoverable error state.",
+    "- Components follow the design system tokens and accessibility baseline.",
+    "- No production app code, network integration, Pro entitlement, `.sdtk/atlas`, or SDTK-WIKI mutation is implied by this handoff.",
+    "",
+    "## Non-Goals",
+    "",
+    "- Figma, Lovable, v0, or full app-builder replacement behavior.",
+    "- Enterprise CRM automation, complex analytics, billing, or multi-team administration.",
+    "- Package publish or deployment.",
+    "",
+  ].join("\n");
+}
+
+function runDesignHandoff({ 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);
+  const missing = requiredArtifacts(paths).filter((artifact) => !fs.existsSync(artifact.filePath));
+  if (missing.length > 0) {
+    const missingList = missing.map((artifact) => artifact.relativePath).join(", ");
+    throw new ValidationError(`Missing required design artifacts: ${missingList}. Run the previous SDTK-DESIGN commands first. No project files were changed.`);
+  }
+  if (fs.existsSync(paths.designHandoffPath) && !force) {
+    throw new ValidationError("docs/design/DESIGN_HANDOFF.md already exists. Re-run with --force to replace this managed handoff.");
+  }
+
+  fs.mkdirSync(path.dirname(paths.designHandoffPath), { recursive: true });
+  fs.writeFileSync(paths.designHandoffPath, handoffContent(), "utf-8");
+
+  return {
+    projectPath: resolvedProjectPath,
+    relativeDesignHandoffPath: "docs/design/DESIGN_HANDOFF.md",
+    forced: Boolean(force),
+  };
+}
+
+function cmdHandoff(args) {
+  const { flags } = parseFlags(args || [], HANDOFF_FLAG_DEFS);
+  if (flags.help) return cmdHandoffHelp();
+
+  const result = runDesignHandoff({
+    projectPath: flags["project-path"],
+    force: Boolean(flags.force),
+  });
+
+  console.log(`[design] Wrote ${result.relativeDesignHandoffPath}: ${result.projectPath}`);
+  console.log(`[design] Verdict: READY_FOR_SDTK_CODE`);
+  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.");
+  return 0;
+}
+
+module.exports = {
+  cmdHandoff,
+  cmdHandoffHelp,
+  handoffContent,
+  requiredArtifacts,
+  runDesignHandoff,
+};

package/src/commands/help.js

@@ -0,0 +1,67 @@
+"use strict";
+
+function cmdHelp() {
+  console.log(`SDTK-DESIGN Kit
+
+Usage:
+  sdtk-design --help
+  sdtk-design --version
+  sdtk-design init
+  sdtk-design start --idea "<idea>"
+  sdtk-design brief --idea "<idea>"
+  sdtk-design screens
+  sdtk-design wireframe --screen landing
+  sdtk-design system
+  sdtk-design review --artifact docs/design/wireframes/LANDING.md
+  sdtk-design handoff
+  sdtk-design status
+
+Examples:
+  sdtk-design start --idea "I want to build a lightweight CRM for solo consultants to track leads."
+  sdtk-design review --artifact docs/design/wireframes/LANDING.md
+  sdtk-design handoff
+  sdtk-design status
+
+Foundation Beta purpose:
+  SDTK-DESIGN is a local-first MVP design planner and reviewer for solo founders.
+  It turns a rough MVP idea into reviewable design artifacts and a deterministic SDTK-CODE handoff.
+
+Required human-facing output:
+  docs/design/DESIGN_BRIEF.md
+  docs/design/SCREEN_MAP.md
+  docs/design/DESIGN_SYSTEM.md
+  docs/design/wireframes/LANDING.md
+  docs/design/wireframes/ONBOARDING.md
+  docs/design/wireframes/DASHBOARD.md
+  docs/design/reviews/DESIGN_REVIEW_YYYYMMDD.md
+  docs/design/DESIGN_HANDOFF.md
+
+Command status:
+  help, --version       Available.
+  init                  Available.
+  brief                 Available.
+  screens               Available.
+  wireframe             Available.
+  system                Available.
+  handoff               Available.
+  review                Available for local markdown artifacts.
+  start                 Available beginner facade.
+  status                Available.
+
+Deferred:
+  URL/browser/screenshot/vision review is not implemented in Foundation Beta.
+  Publishing checks are maintainer-controlled and are not part of normal CLI usage.
+
+Safety boundaries:
+  No production app code generation.
+  No Figma, Lovable, v0, or full app-builder replacement claim.
+  No network call or Pro entitlement requirement by default.
+  No .sdtk/atlas creation or mutation.
+  No SDTK-WIKI output mutation.
+  No overwrite of user files unless a command explicitly supports --force and tests cover it.`);
+  return 0;
+}
+
+module.exports = {
+  cmdHelp,
+};