start-vibing-stacks 1.2.0 → 1.3.0

package/dist/index.js

@@ -238,10 +238,23 @@ async function main() {
     console.log(chalk.green.bold('  🎸 Ready to vibe!'));
     console.log('');
     if (!FLAGS.noClaude) {
-        console.log(chalk.dim('  Launching Claude Code...'));
-        console.log(chalk.dim('  Run: claude --dangerously-skip-permissions'));
+        console.log(chalk.dim('  Launching Claude Code...\n'));
+        const { execSync: run } = await import('child_process');
+        try {
+            run('claude --dangerously-skip-permissions', {
+                cwd: projectDir,
+                stdio: 'inherit',
+                env: { ...process.env },
+            });
+        }
+        catch {
+            console.log('');
+            ui.info('Claude Code session ended. Run again with: claude --dangerously-skip-permissions');
+        }
+    }
+    else {
+        console.log(chalk.dim('  Run: claude --dangerously-skip-permissions\n'));
     }
-    console.log('');
 }
 main().catch((err) => {
     ui.error(`Unexpected error: ${err}`);

package/dist/setup.js

@@ -134,8 +134,18 @@ export async function setupProject(projectDir, config, options = {}) {
         if (existsSync(sharedCommandsDir)) {
             copyDirRecursive(sharedCommandsDir, join(claudeDir, 'commands'), options.force);
         }
-        // 13. Write settings.json for Claude Code
+        // 13. Write settings.json for Claude Code (complete config)
         const settings = {
+            model: 'sonnet',
+            max_tokens: 8192,
+            max_turns: 100,
+            enableAllProjectMcpServers: true,
+            context: {
+                compaction_threshold: 0.85,
+                enable_compaction: true,
+                enable_semantic_search: true,
+                memory_files: ['.claude/CLAUDE.md', 'CLAUDE.md'],
+            },
             permissions: {
                 allow: [
                     'Bash(*)',
@@ -149,7 +159,93 @@ export async function setupProject(projectDir, config, options = {}) {
                 ],
                 deny: [],
             },
+            hooks: {
+                UserPromptSubmit: [
+                    {
+                        matcher: '',
+                        hooks: [
+                            {
+                                type: 'command',
+                                command: 'npx tsx .claude/hooks/run-hook.ts user-prompt-submit',
+                                timeout: 10,
+                            },
+                        ],
+                    },
+                ],
+                Stop: [
+                    {
+                        hooks: [
+                            {
+                                type: 'command',
+                                command: 'npx tsx .claude/hooks/run-hook.ts stop-validator',
+                                timeout: 30,
+                            },
+                        ],
+                    },
+                ],
+            },
+            agents: {
+                'research-web': {
+                    description: 'Researches best practices before implementation',
+                },
+                'documenter': {
+                    description: 'Creates and maintains domain documentation',
+                },
+                'domain-updater': {
+                    description: 'Records session learnings in domain docs',
+                },
+                'commit-manager': {
+                    description: 'Manages commits and git workflow',
+                },
+                'claude-md-compactor': {
+                    description: 'Compacts CLAUDE.md when it exceeds 40k chars',
+                },
+                'tester': {
+                    description: 'Creates tests using the stack-appropriate framework',
+                },
+            },
+            workflow: {
+                default_flow: [
+                    'research-web',
+                    'tester',
+                    'documenter',
+                    'domain-updater',
+                    'commit-manager',
+                ],
+                config_flow: ['domain-updater', 'commit-manager'],
+            },
+            rules: {
+                research: {
+                    required_before_implementation: true,
+                    must_cite_sources: true,
+                },
+                security: {
+                    sanitize_all_responses: true,
+                    owasp_validation_required: true,
+                },
+                testing: {
+                    unit_tests_required: true,
+                    edge_cases_research_required: true,
+                },
+                documentation: {
+                    flow_docs_required: true,
+                    research_must_be_documented: true,
+                },
+            },
         };
+        // Add stack-specific quality gates
+        const stackCfg = loadStackConfig(config.stack);
+        if (stackCfg) {
+            const gates = {};
+            for (const gate of stackCfg.qualityGates) {
+                gates[gate.name.toLowerCase().replace(/\s+/g, '_')] = {
+                    command: gate.command,
+                    required: gate.required,
+                    blocking: gate.required,
+                };
+            }
+            settings.quality_gates = gates;
+        }
         writeFileSync(join(claudeDir, 'settings.json'), JSON.stringify(settings, null, '\t'));
         spinner.succeed(`Setup complete: ${agentCount} agents, ${sharedSkillCount + stackSkillCount} skills, ${hookCount} hooks`);
         return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "start-vibing-stacks",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "AI-powered multi-stack dev workflow for Claude Code. Supports PHP, Node.js, Python and more.",
   "type": "module",
   "bin": {

package/stacks/_shared/hooks/run-hook.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+# Universal Hook Runner — Start Vibing Stacks
+# Tries: bun → npx tsx
+
+HOOK_NAME="$1"
+HOOKS_DIR="$(dirname "$0")"
+
+command_exists() { command -v "$1" >/dev/null 2>&1; }
+
+if command_exists bun && [ -f "$HOOKS_DIR/$HOOK_NAME.ts" ]; then
+    exec bun "$HOOKS_DIR/$HOOK_NAME.ts"
+fi
+
+if command_exists npx && [ -f "$HOOKS_DIR/$HOOK_NAME.ts" ]; then
+    exec npx tsx "$HOOKS_DIR/$HOOK_NAME.ts"
+fi
+
+echo '{"decision":"approve","continue":true,"reason":"No runtime available"}'
+exit 0

package/stacks/_shared/hooks/run-hook.ts

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * Universal Hook Runner — Start Vibing Stacks
+ *
+ * Runtime fallbacks: bun → npx tsx
+ * Usage: npx tsx run-hook.ts <hook-name>
+ */
+
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const HOOKS_DIR = dirname(fileURLToPath(import.meta.url));
+
+function checkRuntime(cmd: string): boolean {
+  try {
+    const result = spawnSync(cmd, ['--version'], {
+      stdio: 'pipe', shell: true, timeout: 5000,
+    });
+    return result.status === 0;
+  } catch { return false; }
+}
+
+function runWithRuntime(cmd: string, args: string[], input: string) {
+  try {
+    const result = spawnSync(cmd, args, {
+      input, shell: true, stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 30000, encoding: 'utf8',
+    });
+    return {
+      exitCode: result.status ?? 1,
+      output: result.stdout?.toString() || '',
+      error: result.stderr?.toString() || undefined,
+    };
+  } catch (err) {
+    return { exitCode: 1, output: '', error: String(err) };
+  }
+}
+
+async function readStdin(timeoutMs: number): Promise<string> {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => { process.stdin.destroy(); resolve('{}'); }, timeoutMs);
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk: string) => { data += chunk; });
+    process.stdin.on('end', () => { clearTimeout(timeout); resolve(data || '{}'); });
+    process.stdin.on('error', () => { clearTimeout(timeout); resolve('{}'); });
+    if (process.stdin.readableEnded) { clearTimeout(timeout); resolve('{}'); }
+  });
+}
+
+async function main(): Promise<void> {
+  const hookName = process.argv[2];
+  if (!hookName) {
+    console.error('[run-hook] Usage: npx tsx run-hook.ts <hook-name>');
+    process.exit(1);
+  }
+
+  const tsPath = join(HOOKS_DIR, `${hookName}.ts`);
+  if (!existsSync(tsPath)) {
+    console.error(`[run-hook] Hook not found: ${tsPath}`);
+    process.stdout.write(JSON.stringify({ decision: 'approve', continue: true, reason: 'Hook not found' }));
+    process.exit(0);
+  }
+
+  const stdinData = await readStdin(2000);
+  const runtimes = [
+    { name: 'bun', cmd: 'bun' },
+    { name: 'npx-tsx', cmd: 'npx tsx' },
+  ];
+
+  for (const runtime of runtimes) {
+    if (!checkRuntime(runtime.cmd.split(' ')[0])) continue;
+
+    const result = runWithRuntime(runtime.cmd, [tsPath], stdinData);
+    process.stdout.write(result.output);
+    if (result.error) process.stderr.write(result.error);
+    process.exit(result.exitCode);
+  }
+
+  console.error('[run-hook] No runtime available');
+  process.stdout.write(JSON.stringify({ decision: 'approve', continue: true, reason: 'No runtime available' }));
+  process.exit(0);
+}
+
+main().catch(() => {
+  process.stdout.write(JSON.stringify({ decision: 'approve', continue: true, reason: 'Hook error' }));
+  process.exit(0);
+});