sinapse-ai 9.3.0 → 9.5.0

package/packages/installer/src/detection/detect-project-type.js

@@ -3,80 +3,198 @@ const path = require('path');
 
 /**
  * Detects the type of project in the current directory
- * 
- * Detection Priority Order:
- * 1. EXISTING_SINAPSE - .sinapse-ai/ directory exists
- * 2. GREENFIELD - directory is empty
- * 3. BROWNFIELD - package.json OR .git exists
- * 4. UNKNOWN - directory has files but no recognized markers
- * 
+ *
  * @param {string} targetDir - Directory to analyze (defaults to process.cwd())
  * @returns {string} 'GREENFIELD' | 'BROWNFIELD' | 'EXISTING_SINAPSE' | 'UNKNOWN'
- * @throws {Error} If directory cannot be accessed
- * 
- * @example
- * // Detect current directory
- * const type = detectProjectType();
- * console.log(type); // 'GREENFIELD'
- * 
- * @example
- * // Detect specific directory
- * const type = detectProjectType('/path/to/project');
- * console.log(type); // 'BROWNFIELD'
  */
 function detectProjectType(targetDir = process.cwd()) {
+  return detectProjectTypeExtended(targetDir).type;
+}
+
+/**
+ * Enhanced project detection with tech stack, maturity score, and recommendations.
+ *
+ * @param {string} targetDir - Directory to analyze (defaults to process.cwd())
+ * @returns {{ type: string, techStack: object, maturityScore: number, recommendations: string[] }}
+ */
+function detectProjectTypeExtended(targetDir = process.cwd()) {
+  if (!targetDir || typeof targetDir !== 'string') {
+    throw new Error('Failed to detect project type: Invalid targetDir parameter: must be a non-empty string');
+  }
+
+  const normalizedDir = path.resolve(targetDir);
+
+  if (!fs.existsSync(normalizedDir)) {
+    throw new Error(`Failed to detect project type: Directory does not exist: ${normalizedDir}`);
+  }
+
   try {
-    // Validate targetDir parameter
-    if (!targetDir || typeof targetDir !== 'string') {
-      throw new Error('Invalid targetDir parameter: must be a non-empty string');
-    }
-
-    // Normalize path for cross-platform compatibility
-    const normalizedDir = path.resolve(targetDir);
-
-    // Check if directory exists before attempting to read
-    if (!fs.existsSync(normalizedDir)) {
-      throw new Error(`Directory does not exist: ${normalizedDir}`);
-    }
-
-    // Check for SINAPSE installation markers (use path.join for security)
-    const hasSinapseCore = fs.existsSync(path.join(normalizedDir, '.sinapse-ai'));
-    
-    // If SINAPSE already installed, return immediately (highest priority)
-    if (hasSinapseCore) {
-      return 'EXISTING_SINAPSE';
-    }
-
-    // Check directory contents
-    const dirContents = fs.readdirSync(normalizedDir);
-    const isEmpty = dirContents.length === 0;
-    
-    // Empty directory = greenfield (second priority)
-    if (isEmpty) {
-      return 'GREENFIELD';
-    }
-
-    // Check for project markers (third priority)
-    const hasPackageJson = fs.existsSync(path.join(normalizedDir, 'package.json'));
-    const hasGit = fs.existsSync(path.join(normalizedDir, '.git'));
-    
-    // Existing project markers = brownfield
-    if (hasPackageJson || hasGit) {
-      return 'BROWNFIELD';
-    }
-
-    // Directory has files but no recognized markers = unknown
-    return 'UNKNOWN';
+    const type = _detectType(normalizedDir);
+    const techStack = type === 'GREENFIELD' ? _emptyStack() : _detectTechStack(normalizedDir);
+    const maturityScore = type === 'GREENFIELD' ? 0 : _calcMaturity(normalizedDir);
+    const recommendations = _buildRecommendations(type, techStack, maturityScore, normalizedDir);
 
+    return { type, techStack, maturityScore, recommendations };
   } catch (error) {
-    // Log error with context for debugging
+    if (error.message.startsWith('Failed to detect project type')) throw error;
     console.error(`[detect-project-type] Error detecting project type in '${targetDir}': ${error.message}`);
-    
-    // Re-throw with more context for caller to handle
     throw new Error(`Failed to detect project type: ${error.message}`);
   }
 }
 
-module.exports = { detectProjectType };
+/** Core type classification (original logic). */
+function _detectType(dir) {
+  if (fs.existsSync(path.join(dir, '.sinapse-ai'))) return 'EXISTING_SINAPSE';
+
+  const dirContents = fs.readdirSync(dir);
+  if (dirContents.length === 0) return 'GREENFIELD';
+
+  const hasPackageJson = fs.existsSync(path.join(dir, 'package.json'));
+  const hasGit = fs.existsSync(path.join(dir, '.git'));
+  if (hasPackageJson || hasGit) return 'BROWNFIELD';
+
+  return 'UNKNOWN';
+}
+
+function _emptyStack() {
+  return { framework: null, language: null, database: null, testing: null, ci: null, containerized: false };
+}
+
+/** Detect tech stack from project files and package.json deps. */
+function _detectTechStack(dir) {
+  const stack = _emptyStack();
+  const deps = _readDeps(dir);
+
+  // Framework detection (priority order)
+  const frameworkMap = [
+    ['next', 'next'], ['nuxt', 'nuxt'], ['@angular/core', 'angular'],
+    ['svelte', 'svelte'], ['vue', 'vue'], ['react', 'react'],
+    ['@nestjs/core', 'nest'], ['fastify', 'fastify'], ['express', 'express'],
+  ];
+  for (const [pkg, name] of frameworkMap) {
+    if (deps.has(pkg)) { stack.framework = name; break; }
+  }
+
+  // Language
+  stack.language = fs.existsSync(path.join(dir, 'tsconfig.json')) ? 'typescript' : 'javascript';
+
+  // Database
+  const dbMap = [['supabase', 'supabase'], ['prisma', 'prisma'], ['drizzle-orm', 'drizzle']];
+  for (const [pkg, name] of dbMap) {
+    if (deps.has(pkg) || deps.has(`@${pkg}/client`)) { stack.database = name; break; }
+  }
+  if (!stack.database && fs.existsSync(path.join(dir, 'supabase'))) stack.database = 'supabase';
+  if (!stack.database && fs.existsSync(path.join(dir, 'prisma'))) stack.database = 'prisma';
+  if (!stack.database && _existsGlob(dir, 'drizzle.config')) stack.database = 'drizzle';
+
+  // Testing
+  const testMap = [['vitest', 'vitest'], ['jest', 'jest'], ['mocha', 'mocha'], ['ava', 'ava']];
+  for (const [pkg, name] of testMap) {
+    if (deps.has(pkg)) { stack.testing = name; break; }
+  }
+  if (!stack.testing) {
+    if (_existsGlob(dir, 'vitest.config')) stack.testing = 'vitest';
+    else if (_existsGlob(dir, 'jest.config')) stack.testing = 'jest';
+  }
+
+  // CI
+  if (fs.existsSync(path.join(dir, '.github', 'workflows'))) stack.ci = 'github-actions';
+  else if (fs.existsSync(path.join(dir, '.gitlab-ci.yml'))) stack.ci = 'gitlab-ci';
+  else if (fs.existsSync(path.join(dir, '.circleci'))) stack.ci = 'circleci';
+
+  // Containers
+  stack.containerized = fs.existsSync(path.join(dir, 'Dockerfile'))
+    || fs.existsSync(path.join(dir, 'docker-compose.yml'))
+    || fs.existsSync(path.join(dir, 'docker-compose.yaml'));
+
+  return stack;
+}
+
+/** Calculate maturity score (0-10). */
+function _calcMaturity(dir) {
+  let score = 0;
+  const has = (p) => fs.existsSync(path.join(dir, p));
+
+  // Tests (+2)
+  if (has('tests') || has('test') || has('__tests__') || has('src/__tests__')) score += 2;
+  // CI/CD (+2)
+  if (has('.github/workflows') || has('.gitlab-ci.yml') || has('.circleci')) score += 2;
+  // Env example (+1)
+  if (has('.env.example') || has('.env.local.example')) score += 1;
+  // README (+1)
+  if (has('README.md') || has('readme.md')) score += 1;
+  // Docs (+1)
+  if (has('docs')) score += 1;
+
+  // >50 files (+1)
+  try {
+    const count = _countFiles(dir, 0, 60);
+    if (count > 50) score += 1;
+  } catch { /* ignore */ }
+
+  // >10 commits (+1)
+  if (has('.git')) {
+    try {
+      const { execSync } = require('child_process');
+      const out = execSync('git rev-list --count HEAD', { cwd: dir, timeout: 3000, stdio: ['pipe', 'pipe', 'pipe'] });
+      if (parseInt(out.toString().trim(), 10) > 10) score += 1;
+    } catch { /* ignore — no git or shallow clone */ }
+  }
+
+  // Branch protection (+1) — check via GitHub API marker or CODEOWNERS
+  if (has('CODEOWNERS') || has('.github/CODEOWNERS')) score += 1;
+
+  return Math.min(score, 10);
+}
 
+/** Build actionable recommendations based on gaps. */
+function _buildRecommendations(type, stack, maturity, dir) {
+  if (type === 'GREENFIELD') return ['Initialize project with SINAPSE scaffolding'];
+  const recs = [];
+  const has = (p) => fs.existsSync(path.join(dir, p));
+
+  if (stack.database === 'supabase') recs.push('Add RLS policies to Supabase tables');
+  if (!stack.testing) recs.push('Add a testing framework (Jest or Vitest recommended)');
+  if (!stack.ci) recs.push('Set up CI/CD with GitHub Actions');
+  if (!has('.env.example') && !has('.env.local.example')) recs.push('Create .env.example with placeholder values');
+  if (!has('README.md') && !has('readme.md')) recs.push('Add a README.md');
+  if (!has('docs')) recs.push('Create a docs/ directory for project documentation');
+  if (!has('CODEOWNERS') && !has('.github/CODEOWNERS')) recs.push('Set up CODEOWNERS for branch protection');
+  if (stack.language === 'javascript' && !has('tsconfig.json')) recs.push('Consider migrating to TypeScript');
+
+  return recs;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/** Read combined deps + devDeps from package.json as a Set. */
+function _readDeps(dir) {
+  const pkgPath = path.join(dir, 'package.json');
+  if (!fs.existsSync(pkgPath)) return new Set();
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return new Set([...Object.keys(pkg.dependencies || {}), ...Object.keys(pkg.devDependencies || {})]);
+  } catch { return new Set(); }
+}
+
+/** Check if a config file exists with common extensions. */
+function _existsGlob(dir, baseName) {
+  return ['.js', '.ts', '.mjs', '.cjs', '.json', '.yaml', '.yml', ''].some(
+    (ext) => fs.existsSync(path.join(dir, `${baseName}${ext}`)),
+  );
+}
+
+/** Recursively count files up to a limit (early exit). */
+function _countFiles(dir, current, limit) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+    current += 1;
+    if (current > limit) return current;
+    if (entry.isDirectory()) current = _countFiles(path.join(dir, entry.name), current, limit);
+    if (current > limit) return current;
+  }
+  return current;
+}
 
+module.exports = { detectProjectType, detectProjectTypeExtended };

package/packages/installer/src/installer/manifest-signature.js

@@ -29,36 +29,48 @@ const SignatureLimits = {
 };
 
 /**
- * PINNED PUBLIC KEY - MUST BE HARDCODED
- * This is the root of trust for manifest verification.
+ * Signature verification feature flag.
+ * Set to true AND provide SINAPSE_MANIFEST_PUBLIC_KEY env var (or replace
+ * the pinned key below) to enable manifest signature verification.
+ */
+const SIGNATURE_VERIFICATION_ENABLED = false;
+
+/**
+ * PINNED PUBLIC KEY - Root of trust for manifest verification.
  * Generated with: minisign -G -p sinapse-ai.pub -s sinapse-ai.key
  *
- * Format: base64-encoded Ed25519 public key
- * DO NOT load this from external files or environment variables.
+ * When SIGNATURE_VERIFICATION_ENABLED is true, the public key MUST be set.
+ * It can be provided via:
+ *   1. SINAPSE_MANIFEST_PUBLIC_KEY environment variable (base64-encoded Ed25519)
+ *   2. Hardcoded below (replace null with the actual key)
+ *
+ * Format: base64-encoded Ed25519 public key (32 bytes)
  */
 const PINNED_PUBLIC_KEY = {
   // Key ID (8 bytes, base64 encoded) - opaque identifier, not UTF-8 text
   // This is compared as raw bytes against the signature's key ID
   keyId: Buffer.from('SINAPSE0001').toString('base64'), // 'QUlPUzAwMDE='
   // Ed25519 public key (32 bytes, base64 encoded)
-  // TODO: Replace with actual generated public key before production
-  publicKey: 'REPLACE_WITH_ACTUAL_PUBLIC_KEY_BASE64_HERE',
+  // Set via env var SINAPSE_MANIFEST_PUBLIC_KEY or hardcode here when production key is generated
+  publicKey: process.env.SINAPSE_MANIFEST_PUBLIC_KEY || null,
   // Algorithm identifier
   algorithm: 'Ed25519',
 };
 
 /**
- * Placeholder key identifier - used to detect uninitialized keys
- * @constant {string}
+ * Check if signature verification is properly configured
+ * @returns {boolean} True if verification is enabled and a key is set
  */
-const PLACEHOLDER_KEY = 'REPLACE_WITH_ACTUAL_PUBLIC_KEY_BASE64_HERE';
+function isVerificationConfigured() {
+  return SIGNATURE_VERIFICATION_ENABLED && PINNED_PUBLIC_KEY.publicKey != null;
+}
 
 /**
- * Check if the pinned public key is still the placeholder
- * @returns {boolean} True if key needs to be replaced
+ * Check if the pinned public key is still the placeholder (legacy compat)
+ * @returns {boolean} True if key is not configured
  */
 function isPlaceholderKey() {
-  return PINNED_PUBLIC_KEY.publicKey === PLACEHOLDER_KEY;
+  return !PINNED_PUBLIC_KEY.publicKey;
 }
 
 /**
@@ -185,12 +197,13 @@ function verifyManifestSignature(manifestContent, signatureContent, options = {}
   };
 
   try {
-    // SECURITY: Check for placeholder key before any verification
+    // SECURITY: Check if verification is properly configured
     const pubKey = options.publicKey || PINNED_PUBLIC_KEY;
-    if (!options.publicKey && isPlaceholderKey()) {
-      result.error =
-        'SECURITY ERROR: Public key has not been configured. ' +
-        'Replace PINNED_PUBLIC_KEY in manifest-signature.js with the actual Ed25519 public key.';
+    if (!options.publicKey && !isVerificationConfigured()) {
+      result.error = 'Signature verification not configured: ' +
+        (SIGNATURE_VERIFICATION_ENABLED
+          ? 'Set SINAPSE_MANIFEST_PUBLIC_KEY env var or hardcode the Ed25519 public key.'
+          : 'SIGNATURE_VERIFICATION_ENABLED is false. Enable when production key is ready.');
       return result;
     }
 
@@ -372,8 +385,10 @@ module.exports = {
   signatureExists,
   loadAndVerifyManifest,
   isPlaceholderKey,
+  isVerificationConfigured,
   parseMinisignSignature,
   PINNED_PUBLIC_KEY,
+  SIGNATURE_VERIFICATION_ENABLED,
   SignatureLimits,
 };
 

package/packages/installer/src/wizard/i18n.js

@@ -33,6 +33,12 @@ const TRANSLATIONS = {
     greenfieldDesc: 'new project from scratch',
     brownfield: 'Brownfield',
     brownfieldDesc: 'existing project',
+    detectedProjectType: 'Detected: {type} project',
+    detectedProjectTypeWithStack: 'Detected: {type} project ({stack})',
+    detectedUpgrade: 'Detected: Existing SINAPSE project (upgrade)',
+    infraApplied: 'Infrastructure templates applied',
+    infraSkipped: 'Infrastructure templates skipped',
+    agentsMdCreated: 'AGENTS.md created',
 
     // IDE selection
     ideQuestion: 'Select IDE(s):',
@@ -210,6 +216,12 @@ const TRANSLATIONS = {
     greenfieldDesc: 'projeto novo do zero',
     brownfield: 'Brownfield',
     brownfieldDesc: 'projeto existente',
+    detectedProjectType: 'Detectado: projeto {type}',
+    detectedProjectTypeWithStack: 'Detectado: projeto {type} ({stack})',
+    detectedUpgrade: 'Detectado: projeto SINAPSE existente (upgrade)',
+    infraApplied: 'Templates de infraestrutura aplicados',
+    infraSkipped: 'Templates de infraestrutura ignorados',
+    agentsMdCreated: 'AGENTS.md criado',
 
     // IDE selection
     ideQuestion: 'Selecione IDE(s):',

package/packages/installer/src/wizard/ide-config-generator.js

@@ -10,7 +10,6 @@
 const fs = require('fs-extra');
 const path = require('path');
 const yaml = require('js-yaml');
-const inquirer = require('inquirer');
 const ora = require('ora');
 const { spawnSync } = require('child_process');
 const { getIDEConfig } = require('../config/ide-configs');
@@ -80,46 +79,16 @@ async function backupFile(filePath) {
  * @param {boolean} options.noMerge - If true, don't offer merge option
  * @returns {Promise<string>} Action: 'merge', 'overwrite', 'skip', or 'backup'
  */
-async function promptFileExists(filePath, options = {}) {
-  const { projectType, forceMerge, noMerge } = options;
-  const canMerge = !noMerge && hasMergeStrategy(filePath);
-  const isBrownfield = projectType === 'BROWNFIELD' || projectType === 'EXISTING_SINAPSE';
-
-  // If force merge is set and merge is available, return merge directly
-  if (forceMerge && canMerge) {
+async function promptFileExists(filePath, _options = {}) {
+  // Story 10.38: Merge-only policy. Users who are not developers must never
+  // be able to destroy their own config by choosing "overwrite" in a prompt.
+  // If the file has a registered merge strategy, merge unconditionally.
+  // Otherwise, fall back to a timestamped backup + overwrite (never plain
+  // overwrite, never skip, never prompt).
+  if (hasMergeStrategy(filePath)) {
     return 'merge';
   }
-
-  // Build choices based on available options
-  const choices = [];
-
-  if (canMerge) {
-    choices.push({
-      name: 'Merge (complement existing)',
-      value: 'merge',
-    });
-  }
-
-  choices.push(
-    { name: 'Overwrite completely', value: 'overwrite' },
-    { name: 'Create backup and overwrite', value: 'backup' },
-    { name: 'Skip', value: 'skip' },
-  );
-
-  // Default to merge for brownfield if available, otherwise backup
-  const defaultChoice = isBrownfield && canMerge ? 'merge' : 'backup';
-
-  const { action } = await inquirer.prompt([
-    {
-      type: 'list',
-      name: 'action',
-      message: `File ${path.basename(filePath)} already exists. What would you like to do?`,
-      choices,
-      default: defaultChoice,
-    },
-  ]);
-
-  return action;
+  return 'backup';
 }
 
 /**

package/packages/installer/src/wizard/index.js

@@ -21,8 +21,9 @@ const {
   getIDEQuestions,
   getTechPresetQuestion,
 } = require('./questions');
-const { setLanguage, t } = require('./i18n');
+const { setLanguage, t, tf } = require('./i18n');
 const yaml = require('js-yaml');
+const { detectProjectTypeExtended } = require('../detection/detect-project-type');
 const { showWelcome, showCompletion, showCancellation } = require('./feedback');
 const { generateIDEConfigs, showSuccessSummary, copySkillFiles, copyExtraCommandFiles } = require('./ide-config-generator');
 const {
@@ -121,6 +122,19 @@ async function writeClaudeSettings(language, projectDir = process.cwd()) {
   }
 }
 
+/** Detect system locale and return wizard language code. */
+function detectSystemLocale() {
+  try {
+    const locale = Intl.DateTimeFormat().resolvedOptions().locale || '';
+    if (locale.startsWith('pt')) return 'pt';
+    if (locale.startsWith('en')) return 'en';
+  } catch (_e) { /* Intl not available */ }
+  const envLocale = process.env.LANG || process.env.LC_ALL || process.env.LC_MESSAGES || '';
+  if (envLocale.startsWith('pt')) return 'pt';
+  if (envLocale.startsWith('en')) return 'en';
+  return null;
+}
+
 /**
  * Get existing language from Claude Code settings.json (Story ACT-12 - Idempotency)
  * Returns the existing language code if found, null otherwise.
@@ -201,20 +215,32 @@ function setupCancellationHandler() {
   sigintHandlerAdded = true;
 }
 
-/**
- * Auto-detect project type based on filesystem markers
- *
- * @param {string} [cwd] - Working directory to inspect
- * @returns {string} 'upgrade' | 'brownfield' | 'greenfield'
- */
-function detectProjectType(cwd = process.cwd()) {
-  if (fse.existsSync(path.join(cwd, '.sinapse-ai'))) {
-    return 'upgrade';
-  }
-  if (fse.existsSync(path.join(cwd, 'package.json'))) {
-    return 'brownfield';
+/** Rich project type detection with tech stack info. */
+function detectProjectTypeFull(cwd = process.cwd()) {
+  try {
+    const extended = detectProjectTypeExtended(cwd);
+    const typeMap = { EXISTING_SINAPSE: 'upgrade', BROWNFIELD: 'brownfield', GREENFIELD: 'greenfield', UNKNOWN: 'greenfield' };
+    const type = typeMap[extended.type] || 'greenfield';
+    let label = '';
+    if (extended.techStack) {
+      const parts = [];
+      if (extended.techStack.framework) parts.push(extended.techStack.framework.charAt(0).toUpperCase() + extended.techStack.framework.slice(1));
+      if (extended.techStack.language === 'typescript') parts.push('TypeScript');
+      if (extended.techStack.database) parts.push(extended.techStack.database.charAt(0).toUpperCase() + extended.techStack.database.slice(1));
+      if (extended.techStack.testing) parts.push(extended.techStack.testing);
+      label = parts.join(' + ');
+    }
+    return { type, techStack: extended.techStack, label };
+  } catch (_err) {
+    if (fse.existsSync(path.join(cwd, '.sinapse-ai'))) return { type: 'upgrade', techStack: null, label: '' };
+    if (fse.existsSync(path.join(cwd, 'package.json'))) return { type: 'brownfield', techStack: null, label: '' };
+    return { type: 'greenfield', techStack: null, label: '' };
   }
-  return 'greenfield';
+}
+
+/** Simple project type string (backward compat). */
+function detectProjectType(cwd = process.cwd()) {
+  return detectProjectTypeFull(cwd).type;
 }
 
 /**
@@ -400,6 +426,45 @@ async function installGlobalAgents() {
  * const answers = await runWizard();
  * console.log(answers.projectType); // 'greenfield', 'brownfield', or 'upgrade'
  */
+
+/** Generate AGENTS.md at project root. */
+async function generateAgentsMd(targetDir = process.cwd()) {
+  const agentsPath = path.join(targetDir, 'AGENTS.md');
+  if (await fse.pathExists(agentsPath)) return false;
+  const lines = [
+    '# AGENTS.md', '', 'Universal agent reference for AI-powered development tools.', '',
+    '## Available Agents', '', '| Agent | Persona | Scope |', '|-------|---------|-------|',
+    '| `@developer` | Pixel | Code implementation |',
+    '| `@quality-gate` | Litmus | Testing and quality |',
+    '| `@architect` | Stratum | Architecture and technical design |',
+    '| `@project-lead` | Beacon | Product Management |',
+    '| `@product-lead` | Axis | Product Owner, stories/epics |',
+    '| `@sprint-lead` | Sync | Scrum Master |',
+    '| `@analyst` | Scope | Research and analysis |',
+    '| `@data-engineer` | Tensor | Database design |',
+    '| `@ux-design-expert` | Mosaic | UX/UI design |',
+    '| `@devops` | Pipeline | CI/CD, deployment |', '',
+    '## Commands', '', 'Use prefix `*` for agent commands:',
+    '- `*help` - Show available commands',
+    '- `*create-story` - Create a development story', '',
+    '---', '*Generated by SINAPSE AI*', '',
+  ];
+  try { await fse.writeFile(agentsPath, lines.join('\n'), 'utf8'); return true; } catch (_e) { return false; }
+}
+
+/** Apply project infrastructure templates (never overwrites existing). */
+function applyInfraTemplates(targetDir = process.cwd()) {
+  try {
+    const infraScript = path.join(__dirname, '..', '..', '..', '..', '.sinapse-ai', 'infrastructure', 'scripts', 'setup-project-infra.js');
+    if (!fse.existsSync(infraScript)) return { success: false, error: 'script not found' };
+    const { run } = require(infraScript);
+    run(targetDir);
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
 async function runWizard(options = {}) {
   try {
     // Setup graceful cancellation
@@ -455,6 +520,14 @@ async function runWizard(options = {}) {
       };
     }
 
+    // Display auto-detected project type (informational)
+    if (detectedProjectType === 'upgrade') {
+      console.log(`\n${colors.primary(t('detectedUpgrade'))}`);
+    } else {
+      const typeLabel = detectedProjectType.charAt(0).toUpperCase() + detectedProjectType.slice(1);
+      console.log(`\n${colors.primary(t('detectedProjectType').replace('{type}', typeLabel))}`);
+    }
+
     // Story 1.4: Install SINAPSE core framework (agents, tasks, workflows, templates)
     console.log('\n📦 Installing SINAPSE core framework...');
     let sinapseCoreResult = null;
@@ -1126,6 +1199,34 @@ async function runWizard(options = {}) {
       }
     }
 
+    // Generate AGENTS.md at project root (universal format for Claude Code + Codex)
+    try {
+      const agentsCreated = await generateAgentsMd(process.cwd());
+      if (agentsCreated) {
+        console.log(`\n✅ ${t('agentsMdCreated')}`);
+      }
+      answers.agentsMdCreated = agentsCreated;
+    } catch (_agentsErr) {
+      answers.agentsMdCreated = false;
+    }
+
+    // Create docs/stories/ directory for story-driven development
+    const storiesDir = path.join(process.cwd(), 'docs', 'stories');
+    if (!await fse.pathExists(storiesDir)) {
+      await fse.ensureDir(storiesDir);
+    }
+
+    // Apply infrastructure templates (PR template, issue templates, CI, CODEOWNERS)
+    try {
+      const infraResult = applyInfraTemplates(process.cwd());
+      if (infraResult.success) {
+        console.log(`✅ ${t('infraApplied')}`);
+      }
+      answers.infraApplied = infraResult.success;
+    } catch (_infraErr) {
+      answers.infraApplied = false;
+    }
+
     // Show completion with LLM label
     showCompletion({ llmLabel: llmLabel(answers.selectedLLM), llmValue: answers.selectedLLM });
 
@@ -1171,11 +1272,15 @@ module.exports = {
     getExistingLanguage,
     LANGUAGE_MAP,
     detectProjectType,
+    detectProjectTypeFull,
     detectTechPreset,
+    detectSystemLocale,
     llmToIDEs,
     llmLabel,
     installGlobalAgents,
     buildAgentTemplate,
+    generateAgentsMd,
+    applyInfraTemplates,
     GLOBAL_AGENTS,
   },
 };

package/packages/installer/src/wizard/questions.js

@@ -82,7 +82,7 @@ function getLLMQuestion() {
 
 /**
  * Get project type question (Story 1.3)
- * Uses i18n for translation
+ * @deprecated Project type is now auto-detected. Kept for backward compat.
  *
  * @returns {Object} Inquirer question object
  */
@@ -317,8 +317,7 @@ function buildQuestionSequence(_context = {}) {
   // Language selection (first question)
   questions.push(getLanguageQuestion());
 
-  // Story 1.2: Foundation (project type only)
-  questions.push(getProjectTypeQuestion());
+  // Story 1.2: Project type is auto-detected (question removed from flow)
 
   // Story 1.4: IDE Selection
   questions.push(...getIDEQuestions());