create-dss-project 0.1.0 → 0.2.0

package/lib/__tests__/project-types.test.js

@@ -0,0 +1,41 @@
+const { PROJECT_TYPES } = require('../project-types');
+
+describe('PROJECT_TYPES', () => {
+  test('has 10 project types', () => {
+    expect(Object.keys(PROJECT_TYPES)).toHaveLength(10);
+  });
+
+  test('every type has required fields', () => {
+    for (const [key, type] of Object.entries(PROJECT_TYPES)) {
+      expect(type).toHaveProperty('label');
+      expect(type).toHaveProperty('description');
+      expect(type).toHaveProperty('discovery');
+      expect(type).toHaveProperty('pipeline');
+      expect(type).toHaveProperty('dashboard');
+      expect(type).toHaveProperty('entityType');
+      expect(type).toHaveProperty('scoringDimensions');
+      expect(typeof type.label).toBe('string');
+      expect(typeof type.discovery).toBe('boolean');
+      expect(Array.isArray(type.scoringDimensions)).toBe(true);
+      expect(type.scoringDimensions.length).toBeGreaterThanOrEqual(3);
+    }
+  });
+
+  test('custom type enables all modules by default', () => {
+    expect(PROJECT_TYPES['custom'].discovery).toBe(true);
+    expect(PROJECT_TYPES['custom'].pipeline).toBe(true);
+    expect(PROJECT_TYPES['custom'].dashboard).toBe(true);
+  });
+
+  test('competitor-research disables discovery and pipeline', () => {
+    expect(PROJECT_TYPES['competitor-research'].discovery).toBe(false);
+    expect(PROJECT_TYPES['competitor-research'].pipeline).toBe(false);
+    expect(PROJECT_TYPES['competitor-research'].dashboard).toBe(true);
+  });
+
+  test('business-case disables all modules', () => {
+    expect(PROJECT_TYPES['business-case'].discovery).toBe(false);
+    expect(PROJECT_TYPES['business-case'].pipeline).toBe(false);
+    expect(PROJECT_TYPES['business-case'].dashboard).toBe(false);
+  });
+});

package/lib/__tests__/scaffold.test.js

@@ -0,0 +1,142 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { scaffold, validateOptions } = require('../scaffold');
+
+describe('validateOptions', () => {
+  const tmpDir = path.join(os.tmpdir(), 'dss-test-' + Date.now());
+  const fakeTemplate = path.join(os.tmpdir(), 'dss-template-' + Date.now());
+
+  beforeAll(() => {
+    // Create a minimal fake template
+    fs.mkdirSync(fakeTemplate, { recursive: true });
+    fs.writeFileSync(path.join(fakeTemplate, 'CLAUDE.md'), '# Test');
+  });
+
+  afterAll(() => {
+    fs.rmSync(fakeTemplate, { recursive: true, force: true });
+    if (fs.existsSync(tmpDir)) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  });
+
+  test('rejects empty project name', () => {
+    expect(() => validateOptions(tmpDir, fakeTemplate, {
+      projectName: '',
+      projectType: 'market-entry',
+      structure: 'full',
+    })).toThrow('Project name is required');
+  });
+
+  test('rejects invalid project name characters', () => {
+    expect(() => validateOptions(tmpDir, fakeTemplate, {
+      projectName: '../bad-path',
+      projectType: 'market-entry',
+      structure: 'full',
+    })).toThrow('Invalid project name');
+  });
+
+  test('rejects unknown project type', () => {
+    expect(() => validateOptions(tmpDir, fakeTemplate, {
+      projectName: 'test-project',
+      projectType: 'nonexistent',
+      structure: 'full',
+    })).toThrow('Unknown project type');
+  });
+
+  test('rejects unknown structure', () => {
+    expect(() => validateOptions(tmpDir, fakeTemplate, {
+      projectName: 'test-project',
+      projectType: 'market-entry',
+      structure: 'ultra',
+    })).toThrow('Unknown structure');
+  });
+
+  test('rejects non-existent template directory', () => {
+    expect(() => validateOptions(tmpDir, '/nonexistent/path', {
+      projectName: 'test-project',
+      projectType: 'market-entry',
+      structure: 'full',
+    })).toThrow('Template directory not found');
+  });
+
+  test('accepts valid options', () => {
+    expect(() => validateOptions(tmpDir, fakeTemplate, {
+      projectName: 'test-project',
+      projectType: 'market-entry',
+      structure: 'full',
+    })).not.toThrow();
+  });
+});
+
+describe('scaffold', () => {
+  const fakeTemplate = path.join(os.tmpdir(), 'dss-scaffold-template-' + Date.now());
+  let targetDir;
+
+  beforeAll(() => {
+    // Create a minimal template with required structure
+    fs.mkdirSync(path.join(fakeTemplate, 'memory'), { recursive: true });
+    fs.mkdirSync(path.join(fakeTemplate, 'research', 'competitors'), { recursive: true });
+    fs.mkdirSync(path.join(fakeTemplate, 'docs'), { recursive: true });
+    fs.writeFileSync(path.join(fakeTemplate, 'CLAUDE.md'), '# {{PROJECT_NAME}}');
+    fs.writeFileSync(path.join(fakeTemplate, 'memory', 'research.md'), '# Research');
+    fs.writeFileSync(path.join(fakeTemplate, 'memory', 'decisions.md'), '# Decisions');
+  });
+
+  beforeEach(() => {
+    targetDir = path.join(os.tmpdir(), 'dss-scaffold-out-' + Date.now());
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(targetDir)) {
+      fs.rmSync(targetDir, { recursive: true, force: true });
+    }
+  });
+
+  afterAll(() => {
+    fs.rmSync(fakeTemplate, { recursive: true, force: true });
+  });
+
+  test('creates project directory with config', () => {
+    const result = scaffold(targetDir, fakeTemplate, {
+      projectName: 'My Project',
+      projectType: 'market-entry',
+      structure: 'full',
+    });
+
+    expect(fs.existsSync(targetDir)).toBe(true);
+    expect(fs.existsSync(path.join(targetDir, 'project.config.json'))).toBe(true);
+
+    const config = JSON.parse(fs.readFileSync(path.join(targetDir, 'project.config.json'), 'utf-8'));
+    expect(config.projectName).toBe('My Project');
+    expect(config.projectType).toBe('market-entry');
+    expect(config.projectSlug).toBe('my-project');
+    expect(result.modules.discovery).toBe(true);
+  });
+
+  test('minimal structure disables all optional modules', () => {
+    const result = scaffold(targetDir, fakeTemplate, {
+      projectName: 'Minimal Test',
+      projectType: 'market-entry',
+      structure: 'minimal',
+    });
+
+    expect(result.modules.discovery).toBe(false);
+    expect(result.modules.pipeline).toBe(false);
+    expect(result.modules.dashboard).toBe(false);
+    expect(result.features.scoring).toBe(false);
+    expect(result.features.evidenceGrading).toBe(false);
+  });
+
+  test('cleans up on failure for non-existent target parent', () => {
+    // This test verifies the error handling path
+    expect(() => scaffold(targetDir, fakeTemplate, {
+      projectName: '',
+      projectType: 'market-entry',
+      structure: 'full',
+    })).toThrow();
+
+    // Target should not exist after cleanup
+    expect(fs.existsSync(targetDir)).toBe(false);
+  });
+});

package/lib/index.js

@@ -1,3 +1,6 @@
+// @ts-check
+'use strict';
+
 const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
@@ -5,7 +8,7 @@ const { askQuestions } = require('./prompts');
 const { scaffold } = require('./scaffold');
 
 async function main(nameArg) {
-  console.log('\n  DS Strategy Stack\n');
+  console.log('\n  DS Strategy Stack — Your Project\'s Second Brain\n');
 
   const answers = await askQuestions(nameArg);
 
@@ -30,41 +33,42 @@ async function main(nameArg) {
 
   console.log(`\n  Creating project in ${targetDir}\n`);
 
-  const { modules } = scaffold(targetDir, templateDir, {
-    projectName: answers.projectName,
-    projectType: answers.projectType,
-    structure: answers.structure,
-  });
-
-  // Git init
   try {
-    execSync('git init', { cwd: targetDir, stdio: 'ignore' });
-    execSync('git add -A', { cwd: targetDir, stdio: 'ignore' });
-    execSync('git commit -m "Initial project from DS Strategy Stack"', {
-      cwd: targetDir,
-      stdio: 'ignore',
+    const { modules } = scaffold(targetDir, templateDir, {
+      projectName: answers.projectName,
+      projectType: answers.projectType,
+      structure: answers.structure,
     });
-    console.log('  ✓ Git repository initialised');
-  } catch {
-    console.log('  ⚠ Could not initialise git — you can do this manually');
-  }
 
-  // Install dashboard dependencies
-  if (modules.dashboard && fs.existsSync(path.join(targetDir, 'dashboard', 'package.json'))) {
-    console.log('  ⏳ Installing dashboard dependencies...');
+    // Git init
     try {
-      execSync('npm install', {
-        cwd: path.join(targetDir, 'dashboard'),
+      execSync('git init', { cwd: targetDir, stdio: 'ignore' });
+      execSync('git add -A', { cwd: targetDir, stdio: 'ignore' });
+      execSync('git commit -m "Initial project from DS Strategy Stack"', {
+        cwd: targetDir,
         stdio: 'ignore',
       });
-      console.log('  ✓ Dashboard dependencies installed');
-    } catch {
-      console.log('  ⚠ Could not install dashboard deps — run "cd dashboard && npm install" manually');
+      console.log('  \u2713 Git repository initialised');
+    } catch (_e) {
+      console.log('  \u26A0 Could not initialise git \u2014 you can do this manually');
     }
-  }
 
-  console.log(`
-  ✅ Project created!
+    // Install dashboard dependencies
+    if (modules.dashboard && fs.existsSync(path.join(targetDir, 'dashboard', 'package.json'))) {
+      console.log('  \u23F3 Installing dashboard dependencies...');
+      try {
+        execSync('npm install', {
+          cwd: path.join(targetDir, 'dashboard'),
+          stdio: 'ignore',
+        });
+        console.log('  \u2713 Dashboard dependencies installed');
+      } catch (_e) {
+        console.log('  \u26A0 Could not install dashboard deps \u2014 run "cd dashboard && npm install" manually');
+      }
+    }
+
+    console.log(`
+  \u2705 Project created!
 
   Next steps:
 
@@ -75,6 +79,10 @@ async function main(nameArg) {
   The /onboard skill will walk you through configuring
   your hypothesis, scoring dimensions, and kill conditions.
 `);
+  } catch (err) {
+    console.error(`\n  Error: ${err.message}\n`);
+    process.exit(1);
+  }
 }
 
 module.exports = { main };

package/lib/project-types.js

@@ -1,3 +1,7 @@
+// @ts-check
+'use strict';
+
+/** @type {Object<string, {label: string, description: string, discovery: boolean, pipeline: boolean, dashboard: boolean, entityType: string, scoringDimensions: string[]}>} */
 const PROJECT_TYPES = {
   'market-entry': {
     label: 'Market Entry',

package/lib/prompts.js

@@ -1,3 +1,6 @@
+// @ts-check
+'use strict';
+
 const prompts = require('prompts');
 const { PROJECT_TYPES } = require('./project-types');
 

package/lib/scaffold.js

@@ -1,3 +1,6 @@
+// @ts-check
+'use strict';
+
 const fs = require('fs');
 const path = require('path');
 const { PROJECT_TYPES } = require('./project-types');
@@ -16,6 +19,7 @@ const EXCLUDE_FROM_COPY = [
   'dashboard/data/scoring.json',
   'dashboard/data/timeline.json',
   'dashboard/data/research.json',
+  'dashboard/data/meta.json',
   'dashboard/screenshot.png',
   'project.config.json',
   'CONTRIBUTING.md',
@@ -23,12 +27,23 @@ const EXCLUDE_FROM_COPY = [
   '.github/pull_request_template.md',
 ];
 
+/**
+ * Check if a relative path should be excluded from copying.
+ * @param {string} relativePath
+ * @returns {boolean}
+ */
 function shouldExclude(relativePath) {
   return EXCLUDE_FROM_COPY.some(ex =>
-    relativePath === ex || relativePath.startsWith(ex + '/')
+    relativePath === ex || relativePath.startsWith(ex + '/'),
   );
 }
 
+/**
+ * Recursively copy a directory, skipping excluded paths.
+ * @param {string} src
+ * @param {string} dest
+ * @param {string} baseDir
+ */
 function copyDir(src, dest, baseDir) {
   fs.mkdirSync(dest, { recursive: true });
   const entries = fs.readdirSync(src, { withFileTypes: true });
@@ -44,13 +59,17 @@ function copyDir(src, dest, baseDir) {
       copyDir(srcPath, destPath, baseDir);
     } else {
       fs.copyFileSync(srcPath, destPath);
-      // Preserve executable permissions
       const stat = fs.statSync(srcPath);
       fs.chmodSync(destPath, stat.mode);
     }
   }
 }
 
+/**
+ * Remove a path if it exists.
+ * @param {string} targetDir
+ * @param {string} relativePath
+ */
 function removeIfExists(targetDir, relativePath) {
   const full = path.join(targetDir, relativePath);
   if (fs.existsSync(full)) {
@@ -58,112 +77,175 @@ function removeIfExists(targetDir, relativePath) {
   }
 }
 
-function scaffold(targetDir, templateDir, options) {
-  const { projectType, structure, projectName } = options;
-  const typeConfig = PROJECT_TYPES[projectType];
+/**
+ * Validate scaffold options before proceeding.
+ * @param {string} targetDir
+ * @param {string} templateDir
+ * @param {{projectName: string, projectType: string, structure: string}} options
+ * @throws {Error} If validation fails
+ */
+function validateOptions(targetDir, templateDir, options) {
+  const { projectName, projectType, structure } = options;
+
+  if (!projectName || typeof projectName !== 'string') {
+    throw new Error('Project name is required.');
+  }
 
-  // 1. Copy template
-  copyDir(templateDir, targetDir, templateDir);
-
-  // 2. Determine effective module flags
-  const modules = {
-    discovery: typeConfig.discovery,
-    pipeline: typeConfig.pipeline,
-    dashboard: typeConfig.dashboard,
-  };
-
-  const features = {
-    scoring: true,
-    killConditions: true,
-    evidenceGrading: true,
-    weeklyReports: true,
-    contextSnapshots: true,
-  };
-
-  // 3. Apply structure-level removals
-  if (structure === 'minimal') {
-    modules.discovery = false;
-    modules.pipeline = false;
-    modules.dashboard = false;
-    features.scoring = false;
-    features.killConditions = false;
-    features.evidenceGrading = false;
-    features.weeklyReports = false;
-    features.contextSnapshots = false;
-
-    removeIfExists(targetDir, 'context');
-    removeIfExists(targetDir, 'skills/compare-options');
-    removeIfExists(targetDir, 'skills/weekly-report');
-    removeIfExists(targetDir, 'skills/rebuild-snapshots');
-    removeIfExists(targetDir, 'memory/scoring.md');
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9 _-]*$/.test(projectName)) {
+    throw new Error(
+      `Invalid project name "${projectName}". Use letters, numbers, spaces, hyphens, or underscores.`,
+    );
   }
 
-  if (structure === 'essentials') {
-    features.scoring = false;
-    features.killConditions = false;
-    features.evidenceGrading = false;
+  if (!PROJECT_TYPES[projectType]) {
+    const valid = Object.keys(PROJECT_TYPES).join(', ');
+    throw new Error(`Unknown project type "${projectType}". Valid types: ${valid}`);
+  }
 
-    removeIfExists(targetDir, 'memory/scoring.md');
-    removeIfExists(targetDir, 'dashboard/scoring.html');
-    removeIfExists(targetDir, 'skills/compare-options');
+  if (!['full', 'essentials', 'minimal'].includes(structure)) {
+    throw new Error(`Unknown structure "${structure}". Valid: full, essentials, minimal`);
   }
 
-  // 4. Apply module-level removals
-  if (!modules.discovery) {
-    removeIfExists(targetDir, 'discovery');
-    removeIfExists(targetDir, 'memory/discovery.md');
-    removeIfExists(targetDir, 'context/pipeline-state.md');
-    removeIfExists(targetDir, 'dashboard/pipeline.html');
-    removeIfExists(targetDir, 'skills/pipeline-update');
-    removeIfExists(targetDir, 'skills/outreach-sequence');
-    removeIfExists(targetDir, 'skills/process-call');
+  if (!fs.existsSync(templateDir)) {
+    throw new Error(`Template directory not found: ${templateDir}`);
   }
 
-  if (!modules.pipeline && modules.discovery) {
-    // Pipeline off but discovery might still be on in custom
-    removeIfExists(targetDir, 'skills/pipeline-update');
-    removeIfExists(targetDir, 'skills/outreach-sequence');
+  if (fs.existsSync(targetDir)) {
+    throw new Error(`Target directory already exists: ${targetDir}`);
   }
+}
 
-  if (!modules.dashboard) {
-    removeIfExists(targetDir, 'dashboard');
+/**
+ * Scaffold a new project from the template.
+ * @param {string} targetDir - Where to create the project
+ * @param {string} templateDir - Source template directory
+ * @param {{projectName: string, projectType: string, structure: string}} options
+ * @returns {{modules: Object, features: Object}}
+ */
+function scaffold(targetDir, templateDir, options) {
+  const { projectType, structure, projectName } = options;
+
+  validateOptions(targetDir, templateDir, options);
+
+  const typeConfig = PROJECT_TYPES[projectType];
+
+  // 1. Copy template (wrapped in try/catch for cleanup on failure)
+  try {
+    copyDir(templateDir, targetDir, templateDir);
+  } catch (err) {
+    // Clean up partial copy
+    if (fs.existsSync(targetDir)) {
+      fs.rmSync(targetDir, { recursive: true, force: true });
+    }
+    throw new Error(`Failed to copy template: ${err.message}`);
   }
 
-  // 5. Remove template-repo-only files
-  removeIfExists(targetDir, 'project.config.example.json');
-  removeIfExists(targetDir, 'scripts/reset-to-template.sh');
-  removeIfExists(targetDir, 'scripts/validate-placeholders.sh');
-
-  // 6. Write project.config.json
-  const config = {
-    templateVersion: '1.0.0',
-    templateSource: 'github.com/DiffTheEnder/DSS-Claude-Stack',
-    projectType,
-    projectName,
-    projectSlug: projectName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, ''),
-    oneLineDescription: '',
-    goal: '',
-    team: '',
-    scope: '',
-    outOfScope: '',
-    strategicHypothesis: '',
-    icpDescription: '',
-    entityType: typeConfig.entityType,
-    entityTypePlural: typeConfig.entityType + 's',
-    pipelineSourceOfTruth: 'data/entities.csv',
-    dashboardUrl: '',
-    modules,
-    features,
-    scoringDimensions: typeConfig.scoringDimensions,
-    killConditions: [],
-  };
-
-  fs.writeFileSync(
-    path.join(targetDir, 'project.config.json'),
-    JSON.stringify(config, null, 2) + '\n'
-  );
+  try {
+    // 2. Determine effective module flags
+    const modules = {
+      discovery: typeConfig.discovery,
+      pipeline: typeConfig.pipeline,
+      dashboard: typeConfig.dashboard,
+    };
+
+    const features = {
+      scoring: true,
+      killConditions: true,
+      evidenceGrading: true,
+      weeklyReports: true,
+      contextSnapshots: true,
+    };
+
+    // 3. Apply structure-level removals
+    if (structure === 'minimal') {
+      modules.discovery = false;
+      modules.pipeline = false;
+      modules.dashboard = false;
+      features.scoring = false;
+      features.killConditions = false;
+      features.evidenceGrading = false;
+      features.weeklyReports = false;
+      features.contextSnapshots = false;
+
+      removeIfExists(targetDir, 'context');
+      removeIfExists(targetDir, 'skills/compare-options');
+      removeIfExists(targetDir, 'skills/weekly-report');
+      removeIfExists(targetDir, 'skills/rebuild-snapshots');
+      removeIfExists(targetDir, 'memory/scoring.md');
+    }
+
+    if (structure === 'essentials') {
+      features.scoring = false;
+      features.killConditions = false;
+      features.evidenceGrading = false;
+
+      removeIfExists(targetDir, 'memory/scoring.md');
+      removeIfExists(targetDir, 'dashboard/scoring.html');
+      removeIfExists(targetDir, 'skills/compare-options');
+    }
+
+    // 4. Apply module-level removals
+    if (!modules.discovery) {
+      removeIfExists(targetDir, 'discovery');
+      removeIfExists(targetDir, 'memory/discovery.md');
+      removeIfExists(targetDir, 'context/pipeline-state.md');
+      removeIfExists(targetDir, 'dashboard/pipeline.html');
+      removeIfExists(targetDir, 'skills/pipeline-update');
+      removeIfExists(targetDir, 'skills/outreach-sequence');
+      removeIfExists(targetDir, 'skills/process-call');
+    }
 
-  return { modules, features };
+    if (!modules.pipeline && modules.discovery) {
+      removeIfExists(targetDir, 'skills/pipeline-update');
+      removeIfExists(targetDir, 'skills/outreach-sequence');
+    }
+
+    if (!modules.dashboard) {
+      removeIfExists(targetDir, 'dashboard');
+    }
+
+    // 5. Remove template-repo-only files
+    removeIfExists(targetDir, 'project.config.example.json');
+    removeIfExists(targetDir, 'scripts/reset-to-template.sh');
+    removeIfExists(targetDir, 'scripts/validate-placeholders.sh');
+
+    // 6. Write project.config.json
+    const config = {
+      templateVersion: '1.0.0',
+      templateSource: 'github.com/DiffTheEnder/DSS-Claude-Stack',
+      projectType,
+      projectName,
+      projectSlug: projectName.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/(^-|-$)/g, ''),
+      oneLineDescription: '',
+      goal: '',
+      team: '',
+      scope: '',
+      outOfScope: '',
+      strategicHypothesis: '',
+      icpDescription: '',
+      entityType: typeConfig.entityType,
+      entityTypePlural: typeConfig.entityType + 's',
+      pipelineSourceOfTruth: 'data/entities.csv',
+      dashboardUrl: '',
+      modules,
+      features,
+      scoringDimensions: typeConfig.scoringDimensions,
+      killConditions: [],
+    };
+
+    fs.writeFileSync(
+      path.join(targetDir, 'project.config.json'),
+      JSON.stringify(config, null, 2) + '\n',
+    );
+
+    return { modules, features };
+  } catch (err) {
+    // Clean up on any failure after the initial copy
+    if (fs.existsSync(targetDir)) {
+      fs.rmSync(targetDir, { recursive: true, force: true });
+    }
+    throw new Error(`Scaffold failed: ${err.message}`);
+  }
 }
 
-module.exports = { scaffold };
+module.exports = { scaffold, validateOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-dss-project",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Scaffold a DS Strategy Stack project for Claude Code",
   "bin": {
     "create-dss-project": "./bin/create-dss-project.js"
@@ -24,7 +24,13 @@
   "engines": {
     "node": ">=16.7.0"
   },
+  "scripts": {
+    "test": "jest --verbose"
+  },
   "dependencies": {
     "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
   }
 }