cc-starter 1.0.2 → 1.0.4

package/bin/cc-starter.js

@@ -5,6 +5,7 @@ import { detect } from '../lib/detect.js';
 import { wizard } from '../lib/wizard.js';
 import { scaffold } from '../lib/scaffold.js';
 import { installPlugins } from '../lib/plugins.js';
+import { I18N } from '../lib/constants.js';
 
 async function main() {
   // 1. Banner
@@ -26,25 +27,27 @@ async function main() {
     console.log(chalk.dim('  No specific tech stack detected (empty or new project)\n'));
   }
 
-  // 3. Interactive wizard
+  // 3. Interactive wizard (language selection happens first inside wizard)
   const config = await wizard(techStack);
+  const lang = config.lang || 'en';
+  const t = I18N[lang];
 
   // 4. Scaffold files
-  console.log(chalk.cyan('\n  Scaffolding project...\n'));
+  console.log(chalk.cyan(`\n  ${t.scaffold.scaffolding}\n`));
   const result = await scaffold(config);
 
   // 5. Install plugins
-  await installPlugins(config.plugins);
+  await installPlugins(config.plugins, lang);
 
   // 6. Summary
   console.log(chalk.green.bold(`
   ══════════════════════════════════════════
-  Done! Run 'claude' to start coding.
+  ${t.summary.done}
 
-  Quick commands:
-    node scripts/stats/cocomo.js          → Project cost estimate
-    node scripts/stats/vibe-code.js help  → Token-saving tools
-    node scripts/stats/project-report.js  → HTML statistics
+  ${t.summary.quickCommands}
+    node scripts/stats/cocomo.js          → ${t.summary.costEstimate}
+    node scripts/stats/vibe-code.js help  → ${t.summary.tokenTools}
+    node scripts/stats/project-report.js  → ${t.summary.htmlStats}
   ══════════════════════════════════════════
   `));
 }

package/lib/constants.js

@@ -30,3 +30,106 @@ export const REPORT_STYLES = {
 };
 
 export const DEFAULT_HOURLY_RATE = 80;
+
+export const I18N = {
+  de: {
+    wizard: {
+      title: 'cc-starter — Projekt-Kickstart Assistent',
+      langQuestion: 'Sprache / Language:',
+      projectName: 'Projektname:',
+      projectDescription: 'Kurze Projektbeschreibung (was baust du?):',
+      hourlyRate: 'Stundensatz für COCOMO-Schätzung (€):',
+      reportStyle: 'Report-Stil:',
+      pluginPreset: 'Plugin-Auswahl:',
+      selectPlugins: 'Plugins auswählen:',
+      detectedStack: 'Erkannter Tech-Stack: ',
+      custom: 'Individuell — einzelne Plugins wählen'
+    },
+    scaffold: {
+      scaffolding: 'Projekt wird eingerichtet...',
+      existingClaude: 'Vorhandenes .claude/ gefunden. Was soll passieren?',
+      overwrite: 'Überschreiben — alle Dateien ersetzen',
+      merge: 'Zusammenführen — bestehende behalten, fehlende ergänzen',
+      skip: 'Überspringen — .claude/ nicht ändern',
+      existingClaudeMd: 'Vorhandene CLAUDE.md gefunden. Was soll passieren?',
+      overwriteMd: 'Überschreiben — durch cc-starter Version ersetzen',
+      appendMd: 'Anhängen — cc-starter Abschnitt am Ende einfügen',
+      skipMd: 'Überspringen — CLAUDE.md nicht ändern',
+      created: 'erstellt',
+      skipped: 'übersprungen',
+      appended: 'angehängt',
+      updated: 'aktualisiert',
+      alreadyUpToDate: 'bereits aktuell',
+      done: 'Fertig!',
+      files: 'Dateien'
+    },
+    plugins: {
+      installing: 'Plugins werden installiert...',
+      noPlugins: 'Keine Plugins ausgewählt.',
+      cliNotFound: 'Claude Code CLI nicht gefunden. Plugin-Installation übersprungen.',
+      installFirst: 'Installiere zuerst Claude Code: https://claude.ai/download',
+      manualInstall: 'Dann installiere Plugins manuell:',
+      installed: 'installiert',
+      manualNeeded: 'manuelle Installation nötig:',
+      pluginsInstalled: 'Plugin(s) installiert',
+      pluginsManual: 'Plugin(s) brauchen manuelle Installation'
+    },
+    summary: {
+      done: "Fertig! Starte mit 'claude' zum Coden.",
+      quickCommands: 'Schnellbefehle:',
+      costEstimate: 'Projekt-Kostenschätzung',
+      tokenTools: 'Token-sparende Tools',
+      htmlStats: 'HTML-Statistiken'
+    }
+  },
+  en: {
+    wizard: {
+      title: 'cc-starter — project kickstart wizard',
+      langQuestion: 'Sprache / Language:',
+      projectName: 'Project name:',
+      projectDescription: 'Short project description (what are you building?):',
+      hourlyRate: 'Hourly rate for COCOMO estimation (€):',
+      reportStyle: 'Report style:',
+      pluginPreset: 'Plugin preset:',
+      selectPlugins: 'Select plugins:',
+      detectedStack: 'Detected tech stack: ',
+      custom: 'Custom — pick individual plugins'
+    },
+    scaffold: {
+      scaffolding: 'Scaffolding project...',
+      existingClaude: 'Existing .claude/ found. What should we do?',
+      overwrite: 'Overwrite — replace all files',
+      merge: 'Merge — keep existing, add missing files only',
+      skip: 'Skip — leave .claude/ untouched',
+      existingClaudeMd: 'Existing CLAUDE.md found. What should we do?',
+      overwriteMd: 'Overwrite — replace with cc-starter version',
+      appendMd: 'Append — add cc-starter section at the end',
+      skipMd: 'Skip — leave CLAUDE.md untouched',
+      created: 'created',
+      skipped: 'skipped',
+      appended: 'appended',
+      updated: 'updated',
+      alreadyUpToDate: 'already up to date',
+      done: 'Done!',
+      files: 'files'
+    },
+    plugins: {
+      installing: 'Installing plugins...',
+      noPlugins: 'No plugins selected.',
+      cliNotFound: 'Claude Code CLI not found. Skipping plugin installation.',
+      installFirst: 'Install Claude Code first: https://claude.ai/download',
+      manualInstall: 'Then install plugins manually:',
+      installed: 'installed',
+      manualNeeded: 'manual install needed:',
+      pluginsInstalled: 'plugin(s) installed',
+      pluginsManual: 'plugin(s) need manual installation'
+    },
+    summary: {
+      done: "Done! Run 'claude' to start coding.",
+      quickCommands: 'Quick commands:',
+      costEstimate: 'Project cost estimate',
+      tokenTools: 'Token-saving tools',
+      htmlStats: 'HTML statistics'
+    }
+  }
+};

package/lib/plugins.js

@@ -1,5 +1,6 @@
 import { execSync } from 'node:child_process';
 import chalk from 'chalk';
+import { I18N } from './constants.js';
 
 /**
  * Check whether the `claude` CLI is available on this machine.
@@ -23,19 +24,22 @@ function isClaudeAvailable() {
  *   to manual instructions on failure.
  *
  * @param {Array<{ name: string, source: string }>} plugins
+ * @param {string} [lang='en'] - Language code ('de' or 'en')
  */
-export async function installPlugins(plugins) {
+export async function installPlugins(plugins, lang = 'en') {
+  const t = I18N[lang];
+
   if (!plugins || plugins.length === 0) {
-    console.log(chalk.dim('  No plugins selected.'));
+    console.log(chalk.dim(`  ${t.plugins.noPlugins}`));
     return;
   }
 
   // ── Pre-flight: is the CLI installed? ─────────────────────────────
 
   if (!isClaudeAvailable()) {
-    console.log(chalk.yellow('\n  ⚠ Claude Code CLI not found. Skipping plugin installation.'));
-    console.log(chalk.dim('    Install Claude Code first: https://claude.ai/download'));
-    console.log(chalk.dim('    Then install plugins manually:\n'));
+    console.log(chalk.yellow(`\n  ⚠ ${t.plugins.cliNotFound}`));
+    console.log(chalk.dim(`    ${t.plugins.installFirst}`));
+    console.log(chalk.dim(`    ${t.plugins.manualInstall}\n`));
     for (const p of plugins) {
       console.log(chalk.dim(`    claude plugin install ${p.name}@${p.source}`));
     }
@@ -44,7 +48,7 @@ export async function installPlugins(plugins) {
 
   // ── Install each plugin ───────────────────────────────────────────
 
-  console.log(chalk.cyan('\n  Installing plugins...\n'));
+  console.log(chalk.cyan(`\n  ${t.plugins.installing}\n`));
 
   // Show what will be installed
   for (const p of plugins) {
@@ -63,10 +67,10 @@ export async function installPlugins(plugins) {
         stdio: 'inherit',
         timeout: 30000,
       });
-      console.log(chalk.green(`  ✓ ${plugin.name}`));
+      console.log(chalk.green(`  ✓ ${plugin.name}`) + chalk.dim(` — ${t.plugins.installed}`));
       installed++;
     } catch {
-      console.log(chalk.yellow(`  ⚠ ${plugin.name} — manual install needed:`));
+      console.log(chalk.yellow(`  ⚠ ${plugin.name} — ${t.plugins.manualNeeded}`));
       console.log(chalk.dim(`    claude plugin install ${ref}`));
       failed++;
     }
@@ -75,6 +79,6 @@ export async function installPlugins(plugins) {
   // ── Summary ───────────────────────────────────────────────────────
 
   console.log('');
-  if (installed > 0) console.log(chalk.green(`  ${installed} plugin(s) installed`));
-  if (failed > 0)    console.log(chalk.yellow(`  ${failed} plugin(s) need manual installation`));
+  if (installed > 0) console.log(chalk.green(`  ${installed} ${t.plugins.pluginsInstalled}`));
+  if (failed > 0)    console.log(chalk.yellow(`  ${failed} ${t.plugins.pluginsManual}`));
 }

package/lib/scaffold.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'url';
 import Handlebars from 'handlebars';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
+import { I18N } from './constants.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const TEMPLATE_DIR = path.join(__dirname, '..', 'template');
@@ -15,6 +16,8 @@ const TEMPLATE_DIR = path.join(__dirname, '..', 'template');
  * @returns {Promise<{ filesCreated: number, filesSkipped: number }>}
  */
 export async function scaffold(config, cwd = process.cwd()) {
+  const lang = config.lang || 'en';
+  const t = I18N[lang];
   let filesCreated = 0;
   let filesSkipped = 0;
 
@@ -27,21 +30,21 @@ export async function scaffold(config, cwd = process.cwd()) {
     const answer = await inquirer.prompt([{
       type: 'list',
       name: 'action',
-      message: 'Existing .claude/ found. What should we do?',
+      message: t.scaffold.existingClaude,
       choices: [
-        { name: 'Overwrite — replace all files', value: 'overwrite' },
-        { name: 'Merge — keep existing, add missing files only', value: 'merge' },
-        { name: 'Skip — leave .claude/ untouched', value: 'skip' }
+        { name: t.scaffold.overwrite, value: 'overwrite' },
+        { name: t.scaffold.merge, value: 'merge' },
+        { name: t.scaffold.skip, value: 'skip' }
       ]
     }]);
     claudeAction = answer.action;
   }
 
   if (claudeAction === 'skip') {
-    console.log(chalk.yellow('  ⊘ .claude/') + chalk.dim('                 skipped'));
+    console.log(chalk.yellow('  ⊘ .claude/') + chalk.dim(`                 ${t.scaffold.skipped}`));
     filesSkipped += countFiles(path.join(TEMPLATE_DIR, 'claude'));
   } else {
-    const result = copyClaudeDir(claudeAction, cwd);
+    const result = copyClaudeDir(claudeAction, cwd, lang, t);
     filesCreated += result.created;
     filesSkipped += result.skipped;
   }
@@ -55,53 +58,54 @@ export async function scaffold(config, cwd = process.cwd()) {
     const answer = await inquirer.prompt([{
       type: 'list',
       name: 'action',
-      message: 'Existing CLAUDE.md found. What should we do?',
+      message: t.scaffold.existingClaudeMd,
       choices: [
-        { name: 'Overwrite — replace with cc-starter version', value: 'overwrite' },
-        { name: 'Append — add cc-starter section at the end', value: 'append' },
-        { name: 'Skip — leave CLAUDE.md untouched', value: 'skip' }
+        { name: t.scaffold.overwriteMd, value: 'overwrite' },
+        { name: t.scaffold.appendMd, value: 'append' },
+        { name: t.scaffold.skipMd, value: 'skip' }
       ]
     }]);
     claudeMdAction = answer.action;
   }
 
   if (claudeMdAction === 'skip') {
-    console.log(chalk.yellow('  ⊘ CLAUDE.md') + chalk.dim('               skipped'));
+    console.log(chalk.yellow('  ⊘ CLAUDE.md') + chalk.dim(`               ${t.scaffold.skipped}`));
     filesSkipped += 1;
   } else {
-    renderClaudeMd(config, claudeMdAction, cwd);
+    renderClaudeMd(config, claudeMdAction, cwd, lang);
     filesCreated += 1;
-    console.log(chalk.green('  ✓ CLAUDE.md') + chalk.dim(`               ${claudeMdAction === 'append' ? 'appended' : 'created'}`));
+    console.log(chalk.green('  ✓ CLAUDE.md') + chalk.dim(`               ${claudeMdAction === 'append' ? t.scaffold.appended : t.scaffold.created}`));
   }
 
   // ── 3. Copy scripts/stats/ (always overwrite) ─────────────────────
   const scriptsResult = copyScriptsStats(cwd);
   filesCreated += scriptsResult.created;
-  console.log(chalk.green('  ✓ scripts/stats/') + chalk.dim(`          ${scriptsResult.created} files`));
+  console.log(chalk.green('  ✓ scripts/stats/') + chalk.dim(`          ${scriptsResult.created} ${t.scaffold.files}`));
 
   // ── 4. Create .cc-starter.json (always overwrite) ──────────────────
   const ccConfig = {
     projectName: config.projectName,
     hourlyRate: config.hourlyRate,
     reportStyle: config.reportStyle,
+    lang,
     createdAt: new Date().toISOString(),
     version: '1.0.0'
   };
   fs.writeJsonSync(path.join(cwd, '.cc-starter.json'), ccConfig, { spaces: 2 });
   filesCreated += 1;
-  console.log(chalk.green('  ✓ .cc-starter.json') + chalk.dim('        created'));
+  console.log(chalk.green('  ✓ .cc-starter.json') + chalk.dim(`        ${t.scaffold.created}`));
 
   // ── 5. Update .gitignore ───────────────────────────────────────────
   const gitignoreUpdated = updateGitignore(cwd);
   if (gitignoreUpdated) {
     filesCreated += 1;
-    console.log(chalk.green('  ✓ .gitignore') + chalk.dim('              updated'));
+    console.log(chalk.green('  ✓ .gitignore') + chalk.dim(`              ${t.scaffold.updated}`));
   } else {
-    console.log(chalk.dim('  - .gitignore              already up to date'));
+    console.log(chalk.dim(`  - .gitignore              ${t.scaffold.alreadyUpToDate}`));
   }
 
   console.log();
-  console.log(chalk.bold.green(`  Done!`) + chalk.dim(` ${filesCreated} created, ${filesSkipped} skipped`));
+  console.log(chalk.bold.green(`  ${t.scaffold.done}`) + chalk.dim(` ${filesCreated} ${t.scaffold.created}, ${filesSkipped} ${t.scaffold.skipped}`));
 
   return { filesCreated, filesSkipped };
 }
@@ -111,15 +115,20 @@ export async function scaffold(config, cwd = process.cwd()) {
 /**
  * Copy the template/claude/ tree into cwd/.claude/.
  * In 'merge' mode, only copies files that don't already exist.
+ * Rules are copied from the language-specific subfolder.
  */
-function copyClaudeDir(action, cwd) {
+function copyClaudeDir(action, cwd, lang, t) {
   const src = path.join(TEMPLATE_DIR, 'claude');
   const dest = path.join(cwd, '.claude');
   let created = 0;
   let skipped = 0;
 
+  // Rules come from the language-specific subfolder
+  const rulesSrc = path.join(src, 'rules', lang);
+  const rulesFiles = ['01-general.md', '02-code-standards.md', '03-dev-ops.md', '04-token-efficiency.md'];
+
   const subdirs = [
-    { dir: 'rules',     files: ['01-general.md', '02-code-standards.md', '03-dev-ops.md', '04-token-efficiency.md'] },
+    { dir: 'rules',     files: rulesFiles, srcOverride: rulesSrc },
     { dir: 'memory',    files: ['MEMORY.md'] },
     { dir: 'project',   files: ['README.md'] },
     { dir: 'reference', files: ['README.md'] },
@@ -129,13 +138,14 @@ function copyClaudeDir(action, cwd) {
   // Also copy settings.json at the root of .claude/
   const rootFiles = ['settings.json'];
 
-  for (const { dir, files } of subdirs) {
+  for (const { dir, files, srcOverride } of subdirs) {
     const destDir = path.join(dest, dir);
+    const srcDir = srcOverride || path.join(src, dir);
     fs.ensureDirSync(destDir);
     let dirCreated = 0;
 
     for (const file of files) {
-      const srcFile = path.join(src, dir, file);
+      const srcFile = path.join(srcDir, file);
       const destFile = path.join(destDir, file);
 
       if (action === 'merge' && fs.existsSync(destFile)) {
@@ -149,9 +159,9 @@ function copyClaudeDir(action, cwd) {
     }
 
     if (dirCreated > 0) {
-      console.log(chalk.green(`  ✓ .claude/${dir}/`) + chalk.dim(`          ${dirCreated} file${dirCreated !== 1 ? 's' : ''}`));
+      console.log(chalk.green(`  ✓ .claude/${dir}/`) + chalk.dim(`          ${dirCreated} ${dirCreated !== 1 ? t.scaffold.files : 'file'}`));
     } else {
-      console.log(chalk.yellow(`  ⊘ .claude/${dir}/`) + chalk.dim('          skipped (exists)'));
+      console.log(chalk.yellow(`  ⊘ .claude/${dir}/`) + chalk.dim(`          ${t.scaffold.skipped} (exists)`));
     }
   }
 
@@ -161,28 +171,30 @@ function copyClaudeDir(action, cwd) {
 
     if (action === 'merge' && fs.existsSync(destFile)) {
       skipped += 1;
-      console.log(chalk.yellow(`  ⊘ .claude/${file}`) + chalk.dim('       skipped (exists)'));
+      console.log(chalk.yellow(`  ⊘ .claude/${file}`) + chalk.dim(`       ${t.scaffold.skipped} (exists)`));
       continue;
     }
 
     fs.copySync(srcFile, destFile);
     created += 1;
-    console.log(chalk.green(`  ✓ .claude/${file}`) + chalk.dim('       created'));
+    console.log(chalk.green(`  ✓ .claude/${file}`) + chalk.dim(`       ${t.scaffold.created}`));
   }
 
   return { created, skipped };
 }
 
 /**
- * Render CLAUDE.md from Handlebars template.
+ * Render CLAUDE.md from Handlebars template (language-specific).
  */
-function renderClaudeMd(config, action, cwd) {
-  const templateSrc = fs.readFileSync(path.join(TEMPLATE_DIR, 'CLAUDE.md.hbs'), 'utf-8');
+function renderClaudeMd(config, action, cwd, lang) {
+  const templateFile = `CLAUDE.md.${lang}.hbs`;
+  const templateSrc = fs.readFileSync(path.join(TEMPLATE_DIR, templateFile), 'utf-8');
   const template = Handlebars.compile(templateSrc);
 
   const techStack = config.techStack || { languages: [], frameworks: [] };
   const rendered = template({
     projectName: config.projectName,
+    projectDescription: config.projectDescription || '',
     techStack
   });
 

package/lib/wizard.js

@@ -6,7 +6,8 @@ import {
   PLUGIN_PRESETS,
   ALL_PLUGINS,
   REPORT_STYLES,
-  DEFAULT_HOURLY_RATE
+  DEFAULT_HOURLY_RATE,
+  I18N
 } from './constants.js';
 
 /**
@@ -25,16 +26,32 @@ function detectProjectName() {
 /**
  * Interactive setup wizard.
  * @param {string[]} techStack - Auto-detected technologies (e.g. ['Node.js', 'TypeScript', 'React'])
- * @returns {Promise<{projectName: string, hourlyRate: number, reportStyle: string, plugins: object[], techStack: string[]}>}
+ * @returns {Promise<{projectName: string, hourlyRate: number, reportStyle: string, plugins: object[], techStack: string[], lang: string}>}
  */
 export async function wizard(techStack = []) {
+  // Language selection FIRST — before anything else
+  const { lang } = await inquirer.prompt([{
+    type: 'list',
+    name: 'lang',
+    message: 'Sprache / Language:',
+    choices: [
+      { name: 'Deutsch', value: 'de' },
+      { name: 'English', value: 'en' }
+    ]
+  }]);
+
+  const t = I18N[lang];
+
   console.log();
-  console.log(chalk.bold.cyan('  cc-starter') + chalk.dim(' — project kickstart wizard'));
+  console.log(chalk.bold.cyan('  ' + t.wizard.title));
   console.log();
 
   if (techStack.length > 0) {
-    console.log(chalk.dim('  Detected tech stack: ') + chalk.yellow(techStack.join(', ')));
-    console.log();
+    const detected = [...(techStack.languages || []), ...(techStack.frameworks || [])];
+    if (detected.length > 0) {
+      console.log(chalk.dim('  ' + t.wizard.detectedStack) + chalk.yellow(detected.join(', ')));
+      console.log();
+    }
   }
 
   const defaultName = detectProjectName();
@@ -43,19 +60,24 @@ export async function wizard(techStack = []) {
     {
       type: 'input',
       name: 'projectName',
-      message: 'Project name:',
+      message: t.wizard.projectName,
       default: defaultName
     },
+    {
+      type: 'input',
+      name: 'projectDescription',
+      message: t.wizard.projectDescription
+    },
     {
       type: 'number',
       name: 'hourlyRate',
-      message: 'Hourly rate for COCOMO estimation (\u20ac):',
+      message: t.wizard.hourlyRate,
       default: DEFAULT_HOURLY_RATE
     },
     {
       type: 'list',
       name: 'reportStyle',
-      message: 'Report style:',
+      message: t.wizard.reportStyle,
       choices: Object.entries(REPORT_STYLES).map(([key, val]) => ({
         name: val.label,
         value: key
@@ -64,18 +86,18 @@ export async function wizard(techStack = []) {
     {
       type: 'list',
       name: 'pluginPreset',
-      message: 'Plugin preset:',
+      message: t.wizard.pluginPreset,
       choices: [
         { name: `Minimal  — ${PLUGIN_PRESETS.minimal.map(p => p.name).join(', ')}`,  value: 'minimal' },
         { name: `Standard — ${PLUGIN_PRESETS.standard.map(p => p.name).join(', ')}`, value: 'standard' },
         { name: `Full     — ${PLUGIN_PRESETS.full.map(p => p.name).join(', ')}`,     value: 'full' },
-        { name: 'Custom   — pick individual plugins',                                value: 'custom' }
+        { name: t.wizard.custom, value: 'custom' }
       ]
     },
     {
       type: 'checkbox',
       name: 'customPlugins',
-      message: 'Select plugins:',
+      message: t.wizard.selectPlugins,
       when: (ans) => ans.pluginPreset === 'custom',
       choices: ALL_PLUGINS.map((p) => ({
         name: `${p.name} ${chalk.dim('— ' + p.desc)}`,
@@ -91,9 +113,11 @@ export async function wizard(techStack = []) {
 
   return {
     projectName: answers.projectName,
+    projectDescription: answers.projectDescription || '',
     hourlyRate: answers.hourlyRate,
     reportStyle: answers.reportStyle,
     plugins,
-    techStack
+    techStack,
+    lang
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-starter",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Claude Code Project Kickstart — scaffolds an optimized dev environment with token-saving scripts, COCOMO estimation, and interactive plugin setup",
   "type": "module",
   "bin": {

package/template/CLAUDE.md.de.hbs

@@ -0,0 +1,48 @@
+# CLAUDE.md - {{projectName}}
+
+## Projektübersicht
+**Projekt:** {{projectName}}
+{{#if projectDescription}}
+**Beschreibung:** {{projectDescription}}
+{{/if}}
+{{#if techStack.languages.length}}
+**Sprachen:** {{#each techStack.languages}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}
+{{/if}}
+{{#if techStack.frameworks.length}}
+**Frameworks:** {{#each techStack.frameworks}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}
+{{/if}}
+
+---
+
+## Kurzreferenz
+
+### Token-sparende Scripts
+```bash
+node scripts/stats/vibe-code.js help       # Code-Analyse (~90% Tokens sparen)
+node scripts/stats/vibe-code.js types <f>   # Types/Interfaces extrahieren
+node scripts/stats/vibe-code.js tree [dir]  # Verzeichnisstruktur anzeigen
+node scripts/stats/vibe-code.js imports <f> # Imports anzeigen
+node scripts/stats/vibe-code.js funcs <f>   # Funktions-Signaturen
+```
+
+### Projekt-Statistiken
+```bash
+node scripts/stats/cocomo.js                # Projekt-Kostenschätzung
+node scripts/stats/project-report.js        # HTML-Statistik-Report
+node scripts/stats/vibe-stats.js report     # Token-Einsparungs-Report
+```
+
+### Regeln
+Siehe `.claude/rules/` für Arbeitsregeln:
+- `01-general.md` — Aufgaben-Tracking, Planung, Verifikation
+- `02-code-standards.md` — Code-Qualität, Sicherheit, Tests
+- `03-dev-ops.md` — Git, Umgebung, Deployment
+- `04-token-efficiency.md` — **PFLICHT:** Vibe-Code Scripts nutzen bevor Dateien gelesen werden
+
+### Memory-System
+Persistenter Speicher über Sessions hinweg in `.claude/memory/`.
+Index: `.claude/memory/MEMORY.md`
+
+---
+
+*Generiert von [cc-starter](https://www.npmjs.com/package/cc-starter)*

package/template/CLAUDE.md.en.hbs

@@ -0,0 +1,48 @@
+# CLAUDE.md - {{projectName}}
+
+## Project Overview
+**Project:** {{projectName}}
+{{#if projectDescription}}
+**Description:** {{projectDescription}}
+{{/if}}
+{{#if techStack.languages.length}}
+**Languages:** {{#each techStack.languages}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}
+{{/if}}
+{{#if techStack.frameworks.length}}
+**Frameworks:** {{#each techStack.frameworks}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}
+{{/if}}
+
+---
+
+## Quick Reference
+
+### Token-Saving Scripts
+```bash
+node scripts/stats/vibe-code.js help       # Code analysis (save ~90% tokens)
+node scripts/stats/vibe-code.js types <f>   # Extract types/interfaces
+node scripts/stats/vibe-code.js tree [dir]  # Clean directory tree
+node scripts/stats/vibe-code.js imports <f> # Show imports
+node scripts/stats/vibe-code.js funcs <f>   # Function signatures
+```
+
+### Project Statistics
+```bash
+node scripts/stats/cocomo.js                # Project cost estimation
+node scripts/stats/project-report.js        # HTML statistics report
+node scripts/stats/vibe-stats.js report     # Token savings report
+```
+
+### Rules
+See `.claude/rules/` for working rules:
+- `01-general.md` — Task tracking, planning, verification
+- `02-code-standards.md` — Code quality, security, testing
+- `03-dev-ops.md` — Git, environment, deployment
+- `04-token-efficiency.md` — **MANDATORY:** Use Vibe-Code Scripts before reading files
+
+### Memory System
+Persistent memory across sessions in `.claude/memory/`.
+Index: `.claude/memory/MEMORY.md`
+
+---
+
+*Generated by [cc-starter](https://www.npmjs.com/package/cc-starter)*

package/template/claude/rules/de/01-general.md

@@ -0,0 +1,36 @@
+# Allgemeine Arbeitsregeln
+
+## 1. Aufgaben-Tracking
+Bei Tasks mit **3+ Schritten** IMMER:
+- Aufgaben-Tracking verwenden um Arbeitspakete zu verwalten
+- Jeden Schritt als Aufgabe anlegen BEVOR du anfängst
+- Jeden Punkt sofort als erledigt markieren wenn er fertig ist
+
+## 2. Dokumentation modular halten
+- Keine ausufernden Status-Dateien erstellen
+- Updates gehören in die passende Dokumentation (Feature-Docs, Architektur-Docs)
+- Saubere Trennung der Zuständigkeiten einhalten
+
+## 3. Vor dem Coden
+- Bei Unklarheiten: Erst fragen, dann implementieren
+- Bei mehreren Lösungswegen: Optionen vorstellen und Entscheidung abwarten
+
+## 4. Wenn es nicht klappt: STOPP & Neu planen
+- Wenn ein Ansatz nicht funktioniert: **Sofort stoppen**, nicht weiter probieren
+- Neu planen statt den gleichen Fehler zu wiederholen
+- Ursachen finden — keine temporären Workarounds oder Hacks
+- Frage dich: "Ist das die elegante Lösung oder ein Quick-Fix?"
+
+## 5. Verifikation: Diff gegen Main vor "Fertig"
+- Vor der Fertigmeldung: `git diff main` um sicherzustellen dass alle Änderungen beabsichtigt sind
+- Frage dich: "Würde ein Senior Engineer das so abnehmen?"
+- Build muss grün sein
+- Keine unbeabsichtigten Änderungen in unbeteiligten Dateien
+
+## 6. Design-Dokumentation
+Bei Design-Entscheidungen den Prozess dokumentieren:
+- Zusammenfassung der finalen Entscheidungen
+- Gestellte Fragen mit Optionen und gewählten Antworten
+- Begründung für jede Wahl
+- Technische Details
+- Offene Punkte

package/template/claude/rules/de/02-code-standards.md

@@ -0,0 +1,23 @@
+# Code-Standards
+
+## Sicherheit zuerst
+- Niemals Secrets, API-Keys oder Zugangsdaten committen
+- Alle externen Eingaben validieren
+- Parameterisierte Queries für Datenbanken verwenden
+- OWASP Top 10 Richtlinien befolgen
+
+## Code-Qualität
+- Selbstdokumentierenden Code mit klarer Benennung schreiben
+- Funktionen fokussiert halten (Single Responsibility)
+- Komposition statt Vererbung bevorzugen
+- Fehler explizit behandeln — keine stillen Catches
+
+## Tests
+- Tests für neue Features und Bugfixes schreiben
+- Edge Cases und Fehlerpfade testen
+- Nicht mocken was dir nicht gehört — wenn möglich Integrationstests verwenden
+
+## Internationalisierung (falls zutreffend)
+- Keine hardcodierten User-facing Strings
+- Die i18n-Lösung des Projekts konsistent verwenden
+- Übersetzungsdateien über alle Sprachen synchron halten

package/template/claude/rules/de/03-dev-ops.md

@@ -0,0 +1,20 @@
+# DevOps & Deployment Regeln
+
+## Git-Disziplin
+- Zuständigkeiten in Commits trennen (App-Code vs. Infrastruktur vs. Docs)
+- Aussagekräftige Commit-Messages schreiben die das WARUM erklären, nicht nur das WAS
+- Niemals Force-Push auf main/master ohne Team-Absprache
+
+## Umgebungsvariablen
+- Neue ENV-Variablen müssen dokumentiert werden
+- Niemals .env-Dateien mit echten Werten committen
+- .env.example mit Platzhalter-Werten bereitstellen
+
+## Port-Management
+- Einen Dev-Server-Port verwenden — nicht mehrere starten
+- Verwaiste Prozesse beenden bevor neue Dev-Server gestartet werden
+
+## Build-Verifikation
+- Immer Build/Lint vor dem Committen ausführen
+- Warnungen beheben, nicht unterdrücken
+- CI/CD-Pipeline grün halten

package/template/claude/rules/de/04-token-efficiency.md

@@ -0,0 +1,45 @@
+# Token Efficiency Rules
+
+## PFLICHT: Vibe-Code Scripts BEVOR du große Dateien liest!
+
+**Diese Scripts sparen ~90% Tokens. Nutze sie IMMER bevor du eine Datei mit Read öffnest.**
+
+### Verfügbare Commands
+
+```bash
+# Types/Interfaces/Enums einer Datei extrahieren (statt ganze Datei zu lesen)
+node scripts/stats/vibe-code.js types <file>
+
+# Verzeichnisstruktur anzeigen (statt jeden Ordner einzeln zu lesen)
+node scripts/stats/vibe-code.js tree [dir]
+
+# Imports einer Datei anzeigen (für Dependency-Checks)
+node scripts/stats/vibe-code.js imports <file>
+
+# Funktions-Signaturen extrahieren (statt ganze Datei zu lesen)
+node scripts/stats/vibe-code.js functions <file>
+```
+
+### Wann nutzen
+
+| Situation | Statt | Nutze |
+|-----------|-------|-------|
+| Du willst wissen welche Types eine Datei hat | `Read` der ganzen Datei | `vibe-code.js types <file>` |
+| Du brauchst einen Überblick über einen Ordner | Mehrere `Read`/`ls` Aufrufe | `vibe-code.js tree <dir>` |
+| Du willst Abhängigkeiten einer Datei checken | `Read` und manuell suchen | `vibe-code.js imports <file>` |
+| Du willst die API einer Datei verstehen | `Read` der ganzen Datei | `vibe-code.js functions <file>` |
+
+### NIEMALS
+
+- Große Dateien (200+ Zeilen) komplett lesen ohne vorher `types` oder `functions` zu checken
+- Ordnerstrukturen manuell mit `ls` oder `Glob` erkunden wenn `tree` das in einem Aufruf erledigt
+- Token verschwenden indem du Code liest den du nicht brauchst
+
+### Token-Tracking
+
+Nach der Nutzung werden Einsparungen automatisch in `.vibe-stats.json` getrackt.
+Fortschritt prüfen:
+```bash
+node scripts/stats/vibe-stats.js summary    # Einzeiler: Gesamt-Einsparung
+node scripts/stats/vibe-stats.js report     # Detaillierter Report
+```

package/template/claude/rules/en/01-general.md

@@ -0,0 +1,36 @@
+# General Working Rules
+
+## 1. Task Tracking
+For tasks with **3+ steps** ALWAYS:
+- Use task tracking to manage work items
+- Create each step as a task BEFORE starting
+- Mark each task as completed immediately when done
+
+## 2. Keep Documentation Modular
+- Don't create sprawling status files
+- Updates belong in the matching doc (feature docs, architecture docs)
+- Keep a clean separation of concerns
+
+## 3. Before Coding
+- When unclear: Ask first, then implement
+- When multiple approaches exist: Present options and wait for decision
+
+## 4. When Things Go Wrong: STOP & Re-plan
+- If an approach isn't working: **Stop immediately**, don't keep pushing
+- Re-plan instead of repeating the same mistake
+- Find root causes — no temporary workarounds or hacks
+- Ask yourself: "Is this the elegant solution or a quick-fix?"
+
+## 5. Verification: Diff Against Main Before "Done"
+- Before claiming "done": run `git diff main` to check all changes are intentional
+- Ask yourself: "Would a staff engineer approve this?"
+- Build must be green
+- No unintended changes in unrelated files
+
+## 6. Design Documentation
+When making design decisions, document the process:
+- Summary of final decisions
+- Questions asked with options and chosen answers
+- Reasoning for each choice
+- Technical details
+- Open points

package/template/claude/rules/en/02-code-standards.md

@@ -0,0 +1,23 @@
+# Code Standards
+
+## Security First
+- Never commit secrets, API keys, or credentials
+- Validate all external input
+- Use parameterized queries for databases
+- Follow OWASP Top 10 guidelines
+
+## Code Quality
+- Write self-documenting code with clear naming
+- Keep functions focused (single responsibility)
+- Prefer composition over inheritance
+- Handle errors explicitly — no silent catches
+
+## Testing
+- Write tests for new features and bug fixes
+- Test edge cases and error paths
+- Don't mock what you don't own — use integration tests where possible
+
+## Internationalization (if applicable)
+- No hardcoded user-facing strings
+- Use your project's i18n solution consistently
+- Keep translation files in sync across locales

package/template/claude/rules/en/03-dev-ops.md

@@ -0,0 +1,20 @@
+# DevOps & Deployment Rules
+
+## Git Discipline
+- Separate concerns in commits (app code vs. infrastructure vs. docs)
+- Write descriptive commit messages explaining WHY, not just WHAT
+- Never force-push to main/master without team agreement
+
+## Environment Variables
+- New env vars must be documented
+- Never commit .env files with real values
+- Provide .env.example with placeholder values
+
+## Port Management
+- Stick to one dev server port — don't spawn multiple
+- Kill orphan processes before starting new dev servers
+
+## Build Verification
+- Always run build/lint before committing
+- Fix warnings, don't suppress them
+- Keep CI/CD pipeline green

package/template/claude/rules/en/04-token-efficiency.md

@@ -0,0 +1,45 @@
+# Token Efficiency Rules
+
+## MANDATORY: Use Vibe-Code Scripts BEFORE reading large files!
+
+**These scripts save ~90% tokens. ALWAYS use them before opening a file with Read.**
+
+### Available Commands
+
+```bash
+# Extract types/interfaces/enums from a file (instead of reading the whole file)
+node scripts/stats/vibe-code.js types <file>
+
+# Show directory structure (instead of reading each folder individually)
+node scripts/stats/vibe-code.js tree [dir]
+
+# Show imports of a file (for dependency checks)
+node scripts/stats/vibe-code.js imports <file>
+
+# Extract function signatures (instead of reading the whole file)
+node scripts/stats/vibe-code.js functions <file>
+```
+
+### When to Use
+
+| Situation | Instead of | Use |
+|-----------|------------|-----|
+| You want to know what types a file has | `Read` the whole file | `vibe-code.js types <file>` |
+| You need an overview of a folder | Multiple `Read`/`ls` calls | `vibe-code.js tree <dir>` |
+| You want to check a file's dependencies | `Read` and search manually | `vibe-code.js imports <file>` |
+| You want to understand a file's API | `Read` the whole file | `vibe-code.js functions <file>` |
+
+### NEVER
+
+- Read large files (200+ lines) completely without first checking `types` or `functions`
+- Explore folder structures manually with `ls` or `Glob` when `tree` does it in one call
+- Waste tokens by reading code you don't need
+
+### Token Tracking
+
+After usage, savings are automatically tracked in `.vibe-stats.json`.
+Check progress:
+```bash
+node scripts/stats/vibe-stats.js summary    # One-liner: total savings
+node scripts/stats/vibe-stats.js report     # Detailed report
+```