@nlaprell/shipit 1.0.0

package/_system/security/audit-allowlist.json

@@ -0,0 +1,4 @@
+{
+  "version": 1,
+  "advisories": []
+}

package/bin/create-shipit-app

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+/**
+ * create-shipit-app - Create a new ShipIt project
+ * 
+ * This is an alias for `shipit create <project-name>`
+ */
+
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { spawn } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Get shipit CLI path
+const shipitPath = join(__dirname, 'shipit');
+
+// Forward all arguments to shipit create
+const args = ['create', ...process.argv.slice(2)];
+
+const child = spawn('node', [shipitPath, ...args], {
+  stdio: 'inherit',
+  cwd: process.cwd()
+});
+
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});

package/bin/shipit

@@ -0,0 +1,183 @@
+#!/usr/bin/env node
+
+/**
+ * ShipIt CLI - Main entry point
+ * 
+ * Commands:
+ *   shipit init          - Attach ShipIt to existing project
+ *   shipit upgrade       - Upgrade ShipIt framework files
+ *   shipit check         - Validate ShipIt installation
+ *   shipit create <name> - Create new ShipIt project (alias for create-shipit-app)
+ */
+
+import { program } from 'commander';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync, readFileSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Import CLI modules - use dynamic imports to handle ESM
+let initCommand, upgradeCommand, checkCommand, createCommand, listBackupsCommand, restoreCommand;
+
+async function loadCommands() {
+  const init = await import('../cli/src/commands/init.js');
+  const upgrade = await import('../cli/src/commands/upgrade.js');
+  const check = await import('../cli/src/commands/check.js');
+  const create = await import('../cli/src/commands/create.js');
+  
+  initCommand = init.initCommand;
+  upgradeCommand = upgrade.upgradeCommand;
+  checkCommand = check.checkCommand;
+  createCommand = create.createCommand;
+  listBackupsCommand = upgrade.listBackupsCommand;
+  restoreCommand = upgrade.restoreCommand;
+}
+
+// Get version from package.json
+const packageJsonPath = join(__dirname, '..', 'package.json');
+let version = '0.6.0';
+try {
+  const pkgContent = readFileSync(packageJsonPath, 'utf-8');
+  const pkg = JSON.parse(pkgContent);
+  version = pkg.version || version;
+} catch (e) {
+  // Fallback to default version
+}
+
+// Load commands
+await loadCommands();
+
+program
+  .name('shipit')
+  .description('ShipIt - AI-native Software Development Life Cycle framework')
+  .version(version);
+
+// Init command
+program
+  .command('init')
+  .description('Attach ShipIt to an existing project')
+  .option('--path <dir>', 'Target directory (default: current directory)')
+  .option('--tech-stack <stack>', 'Tech stack (typescript-nodejs | python | other)')
+  .option('--description <text>', 'Project description')
+  .option('--high-risk <domains>', 'Comma-separated high-risk domains')
+  .option('--non-interactive', 'Use defaults/CLI args only, no prompts')
+  .option('--force', 'Overwrite existing ShipIt files')
+  .action(async (options) => {
+    try {
+      await initCommand(options);
+    } catch (error) {
+      console.error(`ERROR: ${error.message}`);
+      if (error.suggestedFix) {
+        console.error(`  ${error.suggestedFix}`);
+      }
+      process.exit(error.exitCode || 2);
+    }
+  });
+
+// Upgrade command
+program
+  .command('upgrade')
+  .description('Upgrade ShipIt framework files to latest version')
+  .option('--path <dir>', 'Target directory (default: current directory)')
+  .option('--backup-dir <dir>', 'Backup directory (default: ._shipit_backup/)')
+  .option('--dry-run', 'Show what would be changed without making changes')
+  .option('--force', 'Skip prompts, overwrite all framework files')
+  .action(async (options) => {
+    try {
+      await upgradeCommand(options);
+    } catch (error) {
+      console.error(`ERROR: ${error.message}`);
+      if (error.suggestedFix) {
+        console.error(`  ${error.suggestedFix}`);
+      }
+      process.exit(error.exitCode || 2);
+    }
+  });
+
+// List backups
+program
+  .command('list-backups')
+  .description('List ShipIt backup files from last upgrade')
+  .option('--path <dir>', 'Target directory (default: current directory)')
+  .option('--backup-dir <dir>', 'Backup directory (default: ._shipit_backup/)')
+  .action(async (options) => {
+    try {
+      await listBackupsCommand(options);
+    } catch (error) {
+      console.error(`ERROR: ${error.message}`);
+      process.exit(error.exitCode || 2);
+    }
+  });
+
+// Restore from backup
+program
+  .command('restore <backup-path>')
+  .description('Restore a file from backup (path relative to project or ._shipit_backup/)')
+  .option('--path <dir>', 'Target directory (default: current directory)')
+  .option('--backup-dir <dir>', 'Backup directory (default: ._shipit_backup/)')
+  .option('--remove-backup', 'Remove backup file after restore')
+  .action(async (backupPath, options) => {
+    try {
+      await restoreCommand(backupPath, options);
+    } catch (error) {
+      console.error(`ERROR: ${error.message}`);
+      process.exit(error.exitCode || 2);
+    }
+  });
+
+// Check command
+program
+  .command('check')
+  .description('Validate ShipIt installation and show project status')
+  .option('--path <dir>', 'Target directory (default: current directory)')
+  .option('--json', 'Output JSON instead of human-readable')
+  .action(async (options) => {
+    try {
+      await checkCommand(options);
+    } catch (error) {
+      console.error(`ERROR: ${error.message}`);
+      if (error.suggestedFix) {
+        console.error(`  ${error.suggestedFix}`);
+      }
+      process.exit(error.exitCode || 2);
+    }
+  });
+
+// Create command
+program
+  .command('create <project-name>')
+  .description('Create a new ShipIt project')
+  .option('--tech-stack <stack>', 'Tech stack (typescript-nodejs | python | other)')
+  .option('--description <text>', 'Project description')
+  .option('--high-risk <domains>', 'Comma-separated high-risk domains')
+  .option('--non-interactive', 'Use defaults/CLI args only, no prompts')
+  .option('--skip-git', 'Don\'t initialize git repo')
+  .option('--skip-install', 'Don\'t run package manager install')
+  .action(async (projectName, options) => {
+    try {
+      await createCommand(projectName, options);
+    } catch (error) {
+      console.error(`ERROR: ${error.message}`);
+      if (error.suggestedFix) {
+        console.error(`  ${error.suggestedFix}`);
+      }
+      process.exit(error.exitCode || 2);
+    }
+  });
+
+// Global error handler
+process.on('unhandledRejection', (error) => {
+  console.error('ERROR: Unhandled error:', error);
+  process.exit(2);
+});
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+  process.exit(0);
+}

package/cli/src/commands/check.js

@@ -0,0 +1,82 @@
+/**
+ * shipit check command - Validate ShipIt installation
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { join, resolve } from 'path';
+import { readManifest } from '../utils/manifest.js';
+
+/**
+ * Check command implementation
+ * @param {object} options - Command options
+ */
+export async function checkCommand(options) {
+  const projectPath = resolve(options.path || process.cwd());
+  const jsonOutput = options.json || false;
+
+  const manifest = readManifest();
+  const status = {
+    initialized: false,
+    projectJsonExists: false,
+    frameworkFiles: {
+      present: [],
+      missing: []
+    },
+    version: null,
+    userCustomizations: []
+  };
+
+  // Check project.json
+  const projectJsonPath = join(projectPath, 'project.json');
+  if (existsSync(projectJsonPath)) {
+    status.projectJsonExists = true;
+    status.initialized = true;
+    
+    try {
+      const projectJson = JSON.parse(readFileSync(projectJsonPath, 'utf-8'));
+      status.version = projectJson.shipitVersion || null;
+    } catch (e) {
+      // Ignore parse errors
+    }
+  }
+
+  // Check framework files
+  for (const file of manifest.frameworkOwned.files || []) {
+    const filePath = join(projectPath, file);
+    if (existsSync(filePath)) {
+      status.frameworkFiles.present.push(file);
+    } else {
+      status.frameworkFiles.missing.push(file);
+    }
+  }
+
+  // Check .override directory
+  const overridePath = join(projectPath, '.override');
+  if (existsSync(overridePath)) {
+    // List files in .override (user customizations)
+    // Simplified - just check if directory exists
+    status.userCustomizations.push('.override/');
+  }
+
+  // Output results
+  if (jsonOutput) {
+    console.log(JSON.stringify(status, null, 2));
+  } else {
+    console.log('ShipIt Installation Check');
+    console.log('========================');
+    console.log(`Initialized: ${status.initialized ? 'Yes' : 'No'}`);
+    if (status.version) {
+      console.log(`Version: ${status.version}`);
+    }
+    console.log(`Framework files present: ${status.frameworkFiles.present.length}`);
+    console.log(`Framework files missing: ${status.frameworkFiles.missing.length}`);
+    if (status.frameworkFiles.missing.length > 0) {
+      console.log('\nMissing files:');
+      status.frameworkFiles.missing.forEach(file => console.log(`  - ${file}`));
+    }
+    if (status.userCustomizations.length > 0) {
+      console.log('\nUser customizations:');
+      status.userCustomizations.forEach(custom => console.log(`  - ${custom}`));
+    }
+  }
+}

package/cli/src/commands/create.js

@@ -0,0 +1,195 @@
+/**
+ * shipit create command - Create new ShipIt project
+ */
+
+import { existsSync, writeFileSync } from 'fs';
+import fsExtra from 'fs-extra';
+
+const { mkdirSync } = fsExtra;
+import { join, resolve } from 'path';
+import { readManifest, getFrameworkRoot } from '../utils/manifest.js';
+import { isValidStack } from '../utils/stack-detection.js';
+import { copyFrameworkFiles } from '../utils/file-copy.js';
+import { createReadlineInterface, promptUser } from '../utils/prompts.js';
+import { execSync } from 'child_process';
+import { getShipitScripts, getShipitDevDependencies } from '../utils/package-json-merge.js';
+import { createTypeScriptNodeFiles, createPythonFiles, createOtherStackFiles, createCIWorkflow } from '../utils/stack-files.js';
+
+/**
+ * Create command implementation
+ * @param {string} projectName - Project name
+ * @param {object} options - Command options
+ */
+export async function createCommand(projectName, options) {
+  const nonInteractive = options.nonInteractive || process.env.SHIPIT_NON_INTERACTIVE === '1';
+  const skipGit = options.skipGit || false;
+  const skipInstall = options.skipInstall || false;
+
+  // Validate project name
+  if (!/^[a-zA-Z0-9_-]+$/.test(projectName)) {
+    throw new Error('Project name must be alphanumeric with hyphens/underscores only');
+  }
+
+  const projectPath = resolve(projectName);
+
+  // Check if directory exists
+  if (existsSync(projectPath)) {
+    if (!options.force && !nonInteractive) {
+      const rl = createReadlineInterface();
+      const answer = await promptUser(rl, `Directory ${projectName} already exists. Continue? (y/N): `);
+      rl.close();
+      if (answer.toLowerCase() !== 'y') {
+        console.log('Aborted.');
+        process.exit(0);
+      }
+    }
+  } else {
+    mkdirSync(projectPath, { recursive: true });
+  }
+
+  // Get tech stack
+  let techStack = options.techStack;
+  if (!techStack && !nonInteractive) {
+    const rl = createReadlineInterface();
+    console.log('Tech stack selection:');
+    console.log('1) TypeScript/Node.js (recommended)');
+    console.log('2) Python');
+    console.log('3) Other (manual setup)');
+    const choice = await promptUser(rl, 'Select tech stack [1=TS/Node, 2=Python, 3=Other]: ');
+    rl.close();
+    
+    switch (choice.trim()) {
+      case '1': techStack = 'typescript-nodejs'; break;
+      case '2': techStack = 'python'; break;
+      case '3': techStack = 'other'; break;
+      default: techStack = 'typescript-nodejs';
+    }
+  }
+  techStack = techStack || 'typescript-nodejs';
+
+  if (!isValidStack(techStack)) {
+    throw new Error(`Invalid tech stack: ${techStack}. Must be typescript-nodejs, python, or other.`);
+  }
+
+  // Get description
+  let description = options.description;
+  if (!description && !nonInteractive) {
+    const rl = createReadlineInterface();
+    description = await promptUser(rl, 'Project description (short): ');
+    rl.close();
+  }
+  description = description || projectName;
+
+  // Get high-risk domains
+  let highRisk = options.highRisk;
+  if (!highRisk && !nonInteractive) {
+    const rl = createReadlineInterface();
+    console.log('High-Risk Domains (comma-separated, or "none"):');
+    console.log('Examples: auth, payments, permissions, infrastructure, pii');
+    highRisk = await promptUser(rl, 'High-risk domains: ');
+    rl.close();
+  }
+  highRisk = highRisk || 'none';
+  const highRiskArray = highRisk === 'none' ? [] : highRisk.split(',').map(s => s.trim());
+
+  console.log(`Creating ShipIt project: ${projectName}`);
+  console.log(`  Tech stack: ${techStack}`);
+  console.log(`  Description: ${description}`);
+
+  // Read manifest
+  const manifest = readManifest();
+  const frameworkRoot = getFrameworkRoot();
+
+  // Copy framework files
+  console.log('Copying framework files...');
+  const copyResult = copyFrameworkFiles(frameworkRoot, projectPath, techStack, manifest, {
+    verbose: !nonInteractive
+  });
+
+  if (copyResult.errors.length > 0) {
+    console.error('Errors during file copy:');
+    copyResult.errors.forEach(err => console.error(`  ${err}`));
+    throw new Error('Failed to copy some framework files');
+  }
+
+  // Create stack-specific files (package.json, tsconfig.json, etc.)
+  if (techStack === 'typescript-nodejs') {
+    const shipitScripts = getShipitScripts();
+    const shipitDevDeps = getShipitDevDependencies();
+    createTypeScriptNodeFiles(projectPath, projectName, description, shipitScripts, shipitDevDeps);
+  } else if (techStack === 'python') {
+    createPythonFiles(projectPath, projectName, description);
+  } else {
+    createOtherStackFiles(projectPath);
+  }
+
+  // Create stack-specific CI workflow
+  createCIWorkflow(projectPath, techStack);
+
+  // Create project.json
+  const projectJson = {
+    name: projectName,
+    description: description,
+    version: '0.1.0',
+    techStack: techStack,
+    created: new Date().toISOString(),
+    highRiskDomains: highRiskArray,
+    settings: {
+      humanResponseTime: 'minutes',
+      confidenceThreshold: 0.7,
+      testCoverageMinimum: 80
+    },
+    shipitVersion: '1.0.0'
+  };
+  writeFileSync(
+    join(projectPath, 'project.json'),
+    JSON.stringify(projectJson, null, 2) + '\n',
+    'utf-8'
+  );
+
+  // Create .override directory structure
+  const overrideDirs = [
+    '.override/rules',
+    '.override/commands',
+    '.override/scripts',
+    '.override/config'
+  ];
+  for (const dir of overrideDirs) {
+    const dirPath = join(projectPath, dir);
+    if (!existsSync(dirPath)) {
+      mkdirSync(dirPath, { recursive: true });
+    }
+  }
+
+  // Initialize git
+  if (!skipGit) {
+    const gitPath = join(projectPath, '.git');
+    if (!existsSync(gitPath)) {
+      console.log('Initializing git repository...');
+      try {
+        execSync('git init', { cwd: projectPath, stdio: 'inherit' });
+        execSync('git add .', { cwd: projectPath, stdio: 'inherit' });
+        execSync('git commit -m "Initial commit: ' + projectName + '"', { cwd: projectPath, stdio: 'inherit' });
+      } catch (error) {
+        console.warn('Warning: Git initialization failed (git may not be installed)');
+      }
+    }
+  }
+
+  // Run package manager install
+  if (!skipInstall && techStack === 'typescript-nodejs') {
+    console.log('Installing dependencies...');
+    try {
+      execSync('pnpm install', { cwd: projectPath, stdio: 'inherit' });
+    } catch (error) {
+      console.warn('Warning: Package installation failed');
+    }
+  }
+
+  console.log('\n✓ Project created successfully!');
+  console.log(`\nNext steps:`);
+  console.log(`1. cd ${projectName}`);
+  console.log('2. Run /scope-project to break down into features');
+  console.log('3. Start creating intents with /new_intent');
+}
+