@nlaprell/shipit 1.0.0

package/cli/src/utils/manifest.js

@@ -0,0 +1,105 @@
+/**
+ * Manifest utilities - Read and parse framework-files-manifest.json
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Get CLI package root directory
+ * @returns {string} Path to CLI package root
+ */
+function getCliPackageRoot() {
+  // When installed: node_modules/shipit/
+  // When local dev: framework root (where bin/ and cli/ are)
+  
+  // Try to find node_modules/shipit from current working directory
+  let currentPath = process.cwd();
+  for (let i = 0; i < 10; i++) { // Limit depth
+    const nodeModulesPath = join(currentPath, 'node_modules', 'shipit');
+    if (existsSync(nodeModulesPath)) {
+      return nodeModulesPath;
+    }
+    const parent = dirname(currentPath);
+    if (parent === currentPath) break; // Reached root
+    currentPath = parent;
+  }
+
+  // Try relative to CLI source (local dev)
+  // cli/src/utils/manifest.js -> framework root
+  const localDevPath = join(__dirname, '..', '..', '..');
+  if (existsSync(join(localDevPath, '_system', 'artifacts', 'framework-files-manifest.json'))) {
+    return localDevPath;
+  }
+
+  // Try relative to bin/ (when installed globally)
+  // bin/shipit -> framework root
+  const binPath = join(__dirname, '..', '..');
+  if (existsSync(join(binPath, '_system', 'artifacts', 'framework-files-manifest.json'))) {
+    return binPath;
+  }
+
+  return null;
+}
+
+/**
+ * Locate framework-files-manifest.json
+ * @returns {string} Path to manifest file
+ */
+export function locateManifest() {
+  const packageRoot = getCliPackageRoot();
+  if (!packageRoot) {
+    throw new Error('ShipIt framework files not found. Reinstall: npm install -g @nlaprell/shipit');
+  }
+
+  const manifestPath = join(packageRoot, '_system', 'artifacts', 'framework-files-manifest.json');
+  if (existsSync(manifestPath)) {
+    return manifestPath;
+  }
+
+  throw new Error('ShipIt framework files not found. Reinstall: npm install -g @nlaprell/shipit');
+}
+
+/**
+ * Read and parse framework-files-manifest.json
+ * @returns {object} Parsed manifest
+ */
+export function readManifest() {
+  const manifestPath = locateManifest();
+  
+  try {
+    const content = readFileSync(manifestPath, 'utf-8');
+    const manifest = JSON.parse(content);
+    
+    // Validate structure
+    if (!manifest.frameworkOwned || !manifest.userOwned || !manifest.stackSpecific || !manifest.neverCopied) {
+      throw new Error('Invalid manifest structure: missing required sections');
+    }
+    
+    return manifest;
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new Error('ShipIt framework files not found. Reinstall: npm install -g @nlaprell/shipit');
+    }
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid manifest JSON: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Get framework root directory (where manifest is located)
+ * @returns {string} Framework root directory
+ */
+export function getFrameworkRoot() {
+  const packageRoot = getCliPackageRoot();
+  if (!packageRoot) {
+    throw new Error('ShipIt framework files not found. Reinstall: npm install -g @nlaprell/shipit');
+  }
+  return packageRoot;
+}

package/cli/src/utils/package-json-merge.js

@@ -0,0 +1,163 @@
+/**
+ * Package.json merge utilities
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Merge ShipIt scripts into existing package.json
+ * @param {string} existingPath - Path to existing package.json
+ * @param {object} shipitScripts - ShipIt scripts to merge
+ * @param {object} shipitDevDeps - ShipIt devDependencies to merge
+ * @param {object} options - Options (dryRun, verbose)
+ * @returns {object} Merge result
+ */
+export function mergePackageJson(existingPath, shipitScripts, shipitDevDeps, options = {}) {
+  const { dryRun = false, verbose = false } = options;
+
+  if (!existsSync(existingPath)) {
+    throw new Error(`package.json not found: ${existingPath}`);
+  }
+
+  // Read existing package.json
+  let existing;
+  try {
+    const content = readFileSync(existingPath, 'utf-8');
+    existing = JSON.parse(content);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Invalid JSON in ${existingPath}: ${error.message}`);
+    }
+    throw error;
+  }
+
+  // Preserve user fields
+  const merged = {
+    ...existing,
+    // Preserve these fields from existing
+    name: existing.name,
+    version: existing.version,
+    description: existing.description,
+    author: existing.author,
+    license: existing.license,
+    repository: existing.repository,
+    homepage: existing.homepage,
+    bugs: existing.bugs,
+    dependencies: existing.dependencies || {},
+    peerDependencies: existing.peerDependencies || {},
+    optionalDependencies: existing.optionalDependencies || {},
+  };
+
+  // Merge scripts
+  const existingScripts = existing.scripts || {};
+  const mergedScripts = { ...existingScripts };
+
+  for (const [scriptName, scriptCommand] of Object.entries(shipitScripts)) {
+    if (existingScripts[scriptName]) {
+      // Collision detected - prefix ShipIt script
+      const prefixedName = `shipit:${scriptName}`;
+      if (!existingScripts[prefixedName] && !existingScripts[`shipit:${scriptName}`]) {
+        mergedScripts[prefixedName] = scriptCommand;
+        if (verbose) {
+          console.log(`  Script collision: ${scriptName} → ${prefixedName}`);
+        }
+      } else {
+        // Already prefixed or user has shipit: prefix, skip
+        if (verbose) {
+          console.log(`  Skipping ${scriptName} (already customized)`);
+        }
+      }
+    } else {
+      // No collision, add directly
+      mergedScripts[scriptName] = scriptCommand;
+    }
+  }
+
+  merged.scripts = mergedScripts;
+
+  // Merge devDependencies
+  const existingDevDeps = existing.devDependencies || {};
+  const mergedDevDeps = { ...existingDevDeps };
+
+  for (const [depName, depVersion] of Object.entries(shipitDevDeps)) {
+    if (!existingDevDeps[depName]) {
+      // Add if missing
+      mergedDevDeps[depName] = depVersion;
+    } else {
+      // Keep existing version (user may have customized)
+      if (verbose) {
+        console.log(`  Keeping existing devDependency: ${depName}@${existingDevDeps[depName]}`);
+      }
+    }
+  }
+
+  merged.devDependencies = mergedDevDeps;
+
+  // Write merged package.json
+  if (!dryRun) {
+    const formatted = JSON.stringify(merged, null, 2);
+    writeFileSync(existingPath, formatted + '\n', 'utf-8');
+  }
+
+  return {
+    merged,
+    collisions: Object.keys(shipitScripts).filter(name => existingScripts[name]),
+    addedScripts: Object.keys(shipitScripts).filter(name => !existingScripts[name]),
+    addedDevDeps: Object.keys(shipitDevDeps).filter(name => !existingDevDeps[name])
+  };
+}
+
+/**
+ * Get ShipIt scripts template
+ * @returns {object} ShipIt scripts object
+ */
+export function getShipitScripts() {
+  // These are the scripts that ShipIt adds to package.json
+  // Based on scripts/init-project.sh package.json template
+  return {
+    'new-intent': './scripts/new-intent.sh',
+    'scope-project': './scripts/scope-project.sh',
+    'generate-roadmap': './scripts/generate-roadmap.sh',
+    'generate-release-plan': './scripts/generate-release-plan.sh',
+    'drift-check': './scripts/drift-check.sh',
+    'deploy': './scripts/deploy.sh',
+    'check-readiness': './scripts/check-readiness.sh',
+    'workflow-orchestrator': './scripts/workflow-orchestrator.sh',
+    'kill-intent': './scripts/kill-intent.sh',
+    'verify': './scripts/verify.sh',
+    'fix': './scripts/fix-intents.sh',
+    'gh-create-issue': './scripts/gh/create-issue-from-intent.sh',
+    'gh-link-issue': './scripts/gh/link-issue.sh',
+    'gh-create-pr': './scripts/gh/create-pr.sh',
+    'on-ship-update-issue': './scripts/gh/on-ship-update-issue.sh',
+    'create-intent-from-issue': './scripts/gh/create-intent-from-issue.sh',
+    'help': './scripts/help.sh',
+    'status': './scripts/status.sh',
+    'suggest': './scripts/suggest.sh',
+    'dashboard': './scripts/dashboard-start.sh',
+    'execute-rollback': './scripts/execute-rollback.sh',
+    'export-dashboard-json': 'node scripts/export-dashboard-json.js'
+  };
+}
+
+/**
+ * Get ShipIt devDependencies template
+ * @returns {object} ShipIt devDependencies object
+ */
+export function getShipitDevDependencies() {
+  // Based on scripts/init-project.sh package.json template
+  return {
+    '@types/node': '^20.10.0',
+    '@typescript-eslint/eslint-plugin': '^6.15.0',
+    '@typescript-eslint/parser': '^6.15.0',
+    '@stryker-mutator/core': '^8.0.0',
+    '@stryker-mutator/vitest-runner': '^8.0.0',
+    '@vitest/coverage-v8': '^1.0.4',
+    'eslint': '^8.56.0',
+    'prettier': '^3.1.1',
+    'tsx': '^4.7.0',
+    'typescript': '^5.3.3',
+    'vitest': '^1.0.4'
+  };
+}

package/cli/src/utils/project-json-merge.js

@@ -0,0 +1,57 @@
+/**
+ * project.json merge for upgrade - preserve user fields, update shipitVersion
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Merge project.json: preserve user fields, update shipitVersion and settings defaults
+ * @param {string} projectPath - Project root
+ * @param {string} newShipitVersion - Version to set
+ * @param {object} options - { dryRun, verbose }
+ * @returns {object} Merge result
+ */
+export function mergeProjectJson(projectPath, newShipitVersion, options = {}) {
+  const { dryRun = false, verbose = false } = options;
+  const projectJsonPath = join(projectPath, 'project.json');
+
+  if (!existsSync(projectJsonPath)) {
+    if (verbose) console.log('  project.json not found, skipping merge');
+    return { merged: null, updated: false };
+  }
+
+  let existing;
+  try {
+    existing = JSON.parse(readFileSync(projectJsonPath, 'utf-8'));
+  } catch (e) {
+    throw new Error(`Invalid JSON in project.json: ${e.message}`);
+  }
+
+  const merged = {
+    ...existing,
+    name: existing.name,
+    description: existing.description,
+    version: existing.version,
+    techStack: existing.techStack,
+    created: existing.created,
+    highRiskDomains: existing.highRiskDomains ?? [],
+    shipitVersion: newShipitVersion,
+    settings: {
+      humanResponseTime: existing.settings?.humanResponseTime ?? 'minutes',
+      confidenceThreshold: existing.settings?.confidenceThreshold ?? 0.7,
+      testCoverageMinimum: existing.settings?.testCoverageMinimum ?? 80,
+      ...(existing.settings || {})
+    }
+  };
+
+  if (!dryRun) {
+    writeFileSync(
+      projectJsonPath,
+      JSON.stringify(merged, null, 2) + '\n',
+      'utf-8'
+    );
+  }
+
+  return { merged, updated: true };
+}

package/cli/src/utils/prompts.js

@@ -0,0 +1,30 @@
+/**
+ * Prompt utilities for interactive mode
+ */
+
+import { createInterface } from 'readline';
+
+/**
+ * Create readline interface
+ * @returns {object} Readline interface
+ */
+export function createReadlineInterface() {
+  return createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+}
+
+/**
+ * Prompt user for input
+ * @param {object} rl - Readline interface
+ * @param {string} question - Question to ask
+ * @returns {Promise<string>} User input
+ */
+export function promptUser(rl, question) {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      resolve(answer);
+    });
+  });
+}

package/cli/src/utils/stack-detection.js

@@ -0,0 +1,56 @@
+/**
+ * Stack detection utilities
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Detect tech stack from existing files
+ * @param {string} projectPath - Path to project directory
+ * @returns {string|null} Detected stack or null if ambiguous/unknown
+ */
+export function detectTechStack(projectPath) {
+  const packageJsonPath = join(projectPath, 'package.json');
+  const pyprojectTomlPath = join(projectPath, 'pyproject.toml');
+  const requirementsTxtPath = join(projectPath, 'requirements.txt');
+  const setupPyPath = join(projectPath, 'setup.py');
+
+  const hasPackageJson = existsSync(packageJsonPath);
+  const hasPyprojectToml = existsSync(pyprojectTomlPath);
+  const hasRequirementsTxt = existsSync(requirementsTxtPath);
+  const hasSetupPy = existsSync(setupPyPath);
+
+  // Check for ambiguous case (both Node and Python indicators)
+  if (hasPackageJson && (hasPyprojectToml || hasRequirementsTxt || hasSetupPy)) {
+    return null; // Ambiguous, prompt user
+  }
+
+  // Validate package.json if it exists
+  if (hasPackageJson) {
+    try {
+      const content = readFileSync(packageJsonPath, 'utf-8');
+      JSON.parse(content); // Validate JSON
+      return 'typescript-nodejs';
+    } catch (e) {
+      return null; // Invalid JSON, prompt user
+    }
+  }
+
+  // Check for Python indicators
+  if (hasPyprojectToml || hasRequirementsTxt || hasSetupPy) {
+    return 'python';
+  }
+
+  // Empty directory or no indicators
+  return null; // Prompt user
+}
+
+/**
+ * Validate stack value
+ * @param {string} stack - Stack value to validate
+ * @returns {boolean} True if valid
+ */
+export function isValidStack(stack) {
+  return ['typescript-nodejs', 'python', 'other'].includes(stack);
+}