hub-launch 1.0.3

package/dist/commands/init.js

@@ -0,0 +1,1243 @@
+import { writeFile, readFile, mkdir, copyFile, chmod, rm, symlink, } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, relative, isAbsolute } from 'path';
+import { logger } from '../utils/logger.js';
+import { getRepoRoot } from '../utils/shell.js';
+import { form, UserCancelledError } from '../utils/prompts.js';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { DEFAULT_CONFIG } from '../types/config.schema.js';
+import { DEFAULT_POLL_INTERVAL_SECONDS } from '../types/common.schema.js';
+import { checkGhVersion } from '../utils/github-cli.js';
+import { parseExistingConfig, mergeConfigs } from '../utils/config-parser.js';
+/**
+ * Init command - Initialize HubLaunch configuration
+ */
+export function initCommand(program, _config) {
+    program
+        .command('init')
+        .description('Initialize HubLaunch configuration (interactive)')
+        .option('--force', 'Overwrite existing configuration')
+        .action(async () => {
+        try {
+            await executeInit();
+        }
+        catch (error) {
+            // Handle user cancellation gracefully
+            if (error instanceof UserCancelledError) {
+                logger.info('\nCancelled.');
+                process.exit(0);
+            }
+            logger.error('Failed to initialize configuration:');
+            logger.error(error instanceof Error ? error.message : String(error));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Get the deployment startup script template based on auth provider
+ */
+function getDeploymentStartupTemplate(authProvider) {
+    const header = `#!/usr/bin/env tsx
+/**
+ * Deployment Startup Script
+ * Automatically logs in to preview deployment before opening
+ *
+ * Context passed as first argument (JSON string):
+ * {
+ *   deploymentUrl: string;
+ *   issueNumber?: number;
+ *   prNumber?: number;
+ *   prTitle?: string;
+ *   prUrl?: string;
+ * }
+ */
+
+import { chromium } from "@playwright/test";
+
+interface HookContext {
+  deploymentUrl: string;
+  issueNumber?: number;
+  prNumber?: number;
+}
+
+async function main() {
+  const contextJson = process.argv[2];
+  if (!contextJson) {
+    console.error("Error: No context provided");
+    process.exit(1);
+  }
+
+  const context: HookContext = JSON.parse(contextJson);
+  console.log(\`🚀 Starting preview for: \${context.deploymentUrl}\`);
+
+  // Browser headless mode: Use env var or default to visible
+  const headless = process.env.CI === "true" || process.env.HEADLESS === "true";
+
+  const browser = await chromium.launch({
+    headless,
+    slowMo: headless ? 0 : 100,
+  });
+
+  const page = await browser.newPage();
+
+  try {
+    await page.goto(context.deploymentUrl);
+`;
+    if (authProvider === 'clerk') {
+        return (header +
+            `
+    // Wait for Clerk authentication widget
+    await page.waitForSelector('[data-clerk-id]', { timeout: 5000 });
+
+    // Click sign-in button
+    await page.click('button:has-text("Sign in")');
+
+    // Fill in credentials from environment
+    const email = process.env.TEST_USER_EMAIL;
+    const password = process.env.TEST_USER_PASSWORD;
+
+    if (!email || !password) {
+      throw new Error(
+        "Required: TEST_USER_EMAIL and TEST_USER_PASSWORD environment variables"
+      );
+    }
+
+    // Enter email
+    await page.fill('input[name="identifier"]', email);
+    await page.click('button:has-text("Continue")');
+
+    // Enter password
+    await page.fill('input[name="password"]', password);
+    await page.click('button:has-text("Continue")');
+
+    // Wait for successful login
+    await page.waitForURL(\`\${context.deploymentUrl}/**\`, {
+      timeout: 10000
+    });
+
+    console.log("✅ Successfully logged in with Clerk!");
+    console.log("Browser will remain open for testing.");
+
+    // Keep browser open - user closes when done
+    // Don't call browser.close()
+
+  } catch (error) {
+    console.error("❌ Login failed:", error);
+    await browser.close();
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);
+`);
+    }
+    if (authProvider === 'auth0') {
+        return (header +
+            `
+    // Wait for Auth0 login form
+    await page.waitForSelector('[name="username"]', { timeout: 5000 });
+
+    // Fill in credentials from environment
+    const email = process.env.TEST_USER_EMAIL;
+    const password = process.env.TEST_USER_PASSWORD;
+
+    if (!email || !password) {
+      throw new Error(
+        "Required: TEST_USER_EMAIL and TEST_USER_PASSWORD environment variables"
+      );
+    }
+
+    // Auth0 login flow
+    await page.fill('input[name="username"]', email);
+    await page.fill('input[name="password"]', password);
+    await page.click('button[type="submit"]');
+
+    // Wait for redirect back to app
+    await page.waitForURL(\`\${context.deploymentUrl}/**\`, {
+      timeout: 10000
+    });
+
+    console.log("✅ Successfully logged in with Auth0!");
+    console.log("Browser will remain open for testing.");
+
+  } catch (error) {
+    console.error("❌ Login failed:", error);
+    await browser.close();
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);
+`);
+    }
+    // Generic template (no auth or custom)
+    return (header +
+        `
+    // Add your custom preview initialization logic here
+    //
+    // Examples:
+    // - Authenticate to deployment
+    // - Seed test data via API
+    // - Configure browser state
+    // - Navigate to specific page
+
+    console.log("✅ Preview setup complete!");
+    console.log("Browser opened at:", context.deploymentUrl);
+
+    // Optionally close browser after delay
+    // await new Promise(resolve => setTimeout(resolve, 30000));
+    // await browser.close();
+
+  } catch (error) {
+    console.error("❌ Preview setup failed:", error);
+    await browser.close();
+    process.exit(1);
+  }
+}
+
+main().catch(console.error);
+`);
+}
+const HOOKS_README_TEMPLATE = `# HubLaunch Hooks
+
+This directory contains project-specific hooks that extend HubLaunch functionality.
+
+## Available Hooks
+
+### \`deploymentStartupScript.ts\`
+Runs before opening a preview deployment. Use for:
+- **Authentication** (Clerk, Auth0, custom login flows)
+- **Browser automation** (Playwright-based interactions)
+- **Test data seeding** (API calls to populate data)
+- **Environment setup** (configure local state)
+
+**Context Provided**:
+\`\`\`typescript
+{
+  deploymentUrl: string;    // Preview deployment URL
+  issueNumber?: number;     // Associated issue number
+  prNumber?: number;        // Associated PR number
+  prTitle?: string;         // PR title
+  prUrl?: string;          // PR URL
+}
+\`\`\`
+
+**Usage**:
+- Configured in \`.hublaunch/hublaunch.config.ts\`
+- Runs automatically when you run \`hula preview\`
+- Runs in **background** (non-blocking)
+
+---
+
+## Creating Custom Hooks
+
+All hooks must:
+1. Be TypeScript files with \`.ts\` extension
+2. Accept context as first CLI argument (JSON string)
+3. Handle errors gracefully (try/catch)
+4. Exit with code 0 on success, non-zero on failure
+
+### Example: Custom Hook
+
+\`\`\`typescript
+#!/usr/bin/env tsx
+
+interface HookContext {
+  [key: string]: unknown;
+}
+
+async function main() {
+  // Parse context from CLI argument
+  const contextJson = process.argv[2];
+  const context: HookContext = JSON.parse(contextJson);
+
+  console.log("Hook executing with context:", context);
+
+  // Your custom logic here
+  // ...
+
+  console.log("✅ Hook completed successfully!");
+}
+
+main().catch((error) => {
+  console.error("❌ Hook failed:", error);
+  process.exit(1);
+});
+\`\`\`
+
+---
+
+## Configuration
+
+Configure hooks in \`.hublaunch/hublaunch.config.ts\`:
+
+\`\`\`typescript
+export const config = {
+  // ... other config ...
+
+  hooks: {
+    deploymentStartup: ".hublaunch/hooks/deploymentStartupScript.ts",
+    beforePreview: ".hublaunch/hooks/beforePreview.ts",  // optional
+    afterPreview: ".hublaunch/hooks/afterPreview.ts",    // optional
+    beforeMerge: ".hublaunch/hooks/beforeMerge.ts",      // optional
+    afterMerge: ".hublaunch/hooks/afterMerge.ts",        // optional
+  },
+};
+\`\`\`
+
+---
+
+## Environment Variables
+
+Store sensitive data in environment variables:
+
+\`\`\`bash
+# .env (gitignored)
+TEST_USER_EMAIL=test@example.com
+TEST_USER_PASSWORD=your-test-password
+CUSTOM_API_KEY=your-api-key
+\`\`\`
+
+Access in hooks:
+\`\`\`typescript
+const email = process.env.TEST_USER_EMAIL;
+\`\`\`
+
+---
+
+## Debugging Hooks
+
+Run hook manually for testing:
+
+\`\`\`bash
+# Test with sample context
+tsx .hublaunch/hooks/deploymentStartupScript.ts '{"deploymentUrl":"https://example.com","prNumber":123}'
+
+# Enable debug mode
+DEBUG=true tsx .hublaunch/hooks/deploymentStartupScript.ts '{"deploymentUrl":"https://example.com"}'
+\`\`\`
+
+---
+
+## More Information
+
+- **Full Documentation**: https://github.com/YizYah/hub-launch/blob/main/docs/hooks-and-plugins.md
+- **Examples**: https://github.com/YizYah/hub-launch/tree/main/examples
+- **Support**: https://github.com/YizYah/hub-launch/issues
+`;
+const ADAPTERS_README_TEMPLATE = `# HubLaunch Adapters
+
+This directory contains custom service adapters for extending HubLaunch functionality.
+
+## Directory Structure
+
+\`\`\`
+adapters/
+└── deployment/        # Custom deployment service adapters
+    └── README.md
+\`\`\`
+
+## What are Adapters?
+
+Adapters allow you to integrate custom services with HubLaunch. For example:
+- **Deployment Services**: Netlify, Railway, custom deployment platforms
+
+## Creating Custom Adapters
+
+All adapters must:
+1. Export as default export
+2. Have a unique \`name\` property
+3. Implement \`isConfigured()\` method
+
+## Configuration
+
+Configure adapters in \`.hublaunch/hublaunch.config.ts\`:
+
+\`\`\`typescript
+export const config = {
+  services: {
+    deployment: {
+      provider: "custom",
+      customPath: ".hublaunch/adapters/deployment/customDeployment.ts",
+    },
+  },
+};
+\`\`\`
+
+## More Information
+
+- **Full Documentation**: https://github.com/YizYah/hub-launch/blob/main/docs/hooks-and-plugins.md
+- **Examples**: https://github.com/YizYah/hub-launch/tree/main/examples/adapters
+`;
+const DEPLOYMENT_ADAPTER_README_TEMPLATE = `# Custom Deployment Service Adapters
+
+Create custom deployment service adapters for your deployment platform.
+
+## Interface
+
+Deployment adapters should implement deployment-related functionality.
+
+## Example: Custom Deployment Service
+
+\`\`\`typescript
+// customDeployment.ts
+export default class CustomDeploymentService {
+  readonly name = "custom";
+
+  isConfigured(): boolean {
+    return Boolean(process.env.CUSTOM_DEPLOY_TOKEN);
+  }
+
+  async getDeploymentUrl(prNumber: number): Promise<string> {
+    // Your implementation
+    const response = await fetch(
+      \`https://your-platform.com/deployments/pr-\${prNumber}\`,
+      {
+        headers: {
+          Authorization: \`Bearer \${process.env.CUSTOM_DEPLOY_TOKEN}\`,
+        },
+      }
+    );
+
+    const data = await response.json();
+    return data.url;
+  }
+}
+\`\`\`
+
+## Configuration
+
+\`\`\`typescript
+// .hublaunch/hublaunch.config.ts
+export const config = {
+  services: {
+    deployment: {
+      provider: "custom",
+      customPath: ".hublaunch/adapters/deployment/customDeployment.ts",
+    },
+  },
+};
+\`\`\`
+`;
+const TEMPLATES_README_TEMPLATE = `# HubLaunch Templates
+
+This directory contains project-specific templates for issues, PRs, and other documents.
+
+## Available Templates
+
+### Issue Templates
+Create custom issue templates for different types of work:
+- \`bug-template.md\`
+- \`feature-template.md\`
+- \`task-template.md\`
+
+### PR Templates
+Create PR description templates:
+- \`pr-template.md\`
+
+## Usage
+
+Templates are automatically detected and used by HubLaunch when creating issues and PRs.
+
+## Example: Issue Template
+
+\`\`\`markdown
+# [Feature Name]
+
+## Description
+[Brief description of the feature]
+
+## Requirements
+- [ ] Requirement 1
+- [ ] Requirement 2
+
+## Acceptance Criteria
+- [ ] Criteria 1
+- [ ] Criteria 2
+
+## Technical Notes
+[Any technical considerations]
+\`\`\`
+`;
+/**
+ * Generate hook templates based on authentication provider
+ */
+async function generateHookTemplates(projectRoot, authProvider, overrideStartupScript) {
+    const hooksDir = join(projectRoot, '.hublaunch/hooks');
+    // Create hooks directory
+    await mkdir(hooksDir, { recursive: true });
+    logger.success(`Created directory: .hublaunch/hooks/`);
+    // Generate deploymentStartupScript.ts template based on auth provider
+    // Only create if auth provider is configured (not "none")
+    if (authProvider !== 'none') {
+        const startupScriptPath = join(hooksDir, 'deploymentStartupScript.ts');
+        if (!existsSync(startupScriptPath)) {
+            const template = getDeploymentStartupTemplate(authProvider);
+            await writeFile(startupScriptPath, template, 'utf-8');
+            logger.success(`Created: .hublaunch/hooks/deploymentStartupScript.ts`);
+        }
+        else if (overrideStartupScript) {
+            const template = getDeploymentStartupTemplate(authProvider);
+            await writeFile(startupScriptPath, template, 'utf-8');
+            logger.success(`Overridden: .hublaunch/hooks/deploymentStartupScript.ts`);
+        }
+        else {
+            logger.info('Keeping existing deploymentStartupScript.ts');
+        }
+    }
+    // Generate README for hooks
+    const readmePath = join(hooksDir, 'README.md');
+    if (!existsSync(readmePath)) {
+        await writeFile(readmePath, HOOKS_README_TEMPLATE, 'utf-8');
+        logger.success(`Created: .hublaunch/hooks/README.md`);
+    }
+    logger.blank();
+    logger.info('📖 See .hublaunch/hooks/README.md for hook documentation');
+}
+/**
+ * Generate adapter directory structure with documentation
+ */
+async function generateAdapterStructure(projectRoot) {
+    const adaptersDir = join(projectRoot, '.hublaunch/adapters');
+    const deploymentDir = join(adaptersDir, 'deployment');
+    // Create adapter directories
+    await mkdir(deploymentDir, { recursive: true });
+    logger.success(`Created directory: .hublaunch/adapters/`);
+    // Generate main adapters README
+    const adaptersReadmePath = join(adaptersDir, 'README.md');
+    if (!existsSync(adaptersReadmePath)) {
+        await writeFile(adaptersReadmePath, ADAPTERS_README_TEMPLATE, 'utf-8');
+        logger.success(`Created: .hublaunch/adapters/README.md`);
+    }
+    // Generate deployment adapter README
+    const deploymentReadmePath = join(deploymentDir, 'README.md');
+    if (!existsSync(deploymentReadmePath)) {
+        await writeFile(deploymentReadmePath, DEPLOYMENT_ADAPTER_README_TEMPLATE, 'utf-8');
+        logger.success(`Created: .hublaunch/adapters/deployment/README.md`);
+    }
+}
+/**
+ * Generate templates directory structure with documentation
+ */
+async function generateTemplatesStructure(projectRoot) {
+    const templatesDir = join(projectRoot, '.hublaunch/templates');
+    // Create templates directory
+    await mkdir(templatesDir, { recursive: true });
+    logger.success(`Created directory: .hublaunch/templates/`);
+    // Generate templates README
+    const templatesReadmePath = join(templatesDir, 'README.md');
+    if (!existsSync(templatesReadmePath)) {
+        await writeFile(templatesReadmePath, TEMPLATES_README_TEMPLATE, 'utf-8');
+        logger.success(`Created: .hublaunch/templates/README.md`);
+    }
+}
+/**
+ * Agent Skills manifest: maps template directory → skill name.
+ * Source: src/templates/skills/<templateDir>/SKILL.md
+ * Canonical destination: .agents/skills/<skillName>/SKILL.md
+ *
+ * .claude/commands/<skillName>.md is created as a symlink into .agents/skills/
+ * so Claude Code can resolve the same file without any content duplication.
+ * Standard: https://agentskills.io/specification
+ */
+const AGENT_SKILLS = [
+    { templateDir: 'hula-plan', skillName: 'hula-plan' },
+    { templateDir: 'hula-confirm', skillName: 'hula-confirm' },
+    { templateDir: 'hula-fix', skillName: 'hula-fix' },
+    { templateDir: 'hula-create', skillName: 'hula-create' },
+    { templateDir: 'hula-verify', skillName: 'hula-verify' },
+    { templateDir: 'hula-merge', skillName: 'hula-merge' },
+    { templateDir: 'hula-launch', skillName: 'hula-launch' },
+    { templateDir: 'hula-upload', skillName: 'hula-upload' },
+    { templateDir: 'hula-log', skillName: 'hula-log' },
+];
+/**
+ * Copy planning instruction templates to .hublaunch/.
+ * These are used by the hula-plan and hula-confirm skills at runtime.
+ */
+async function initializePlanningInstructions(projectRoot, overridePlanningInstructions, overrideProceedInstructions) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const templatesSourceDir = join(__dirname, '..', 'templates');
+    const instructionsTemplatePath = join(templatesSourceDir, 'planning-instructions.md');
+    const instructionsDestPath = join(projectRoot, '.hublaunch', 'planning-instructions.md');
+    if (!existsSync(instructionsDestPath) || overridePlanningInstructions) {
+        await copyFile(instructionsTemplatePath, instructionsDestPath);
+        logger.success('Updated: .hublaunch/planning-instructions.md');
+    }
+    else {
+        logger.info('Keeping existing planning instructions');
+    }
+    const proceedInstructionsTemplatePath = join(templatesSourceDir, 'proceed-instructions.md');
+    const proceedInstructionsDestPath = join(projectRoot, '.hublaunch', 'proceed-instructions.md');
+    if (!existsSync(proceedInstructionsDestPath) || overrideProceedInstructions) {
+        await copyFile(proceedInstructionsTemplatePath, proceedInstructionsDestPath);
+        logger.success('Updated: .hublaunch/proceed-instructions.md');
+    }
+    else {
+        logger.info('Keeping existing proceed instructions');
+    }
+}
+/**
+ * Initialize Agent Skills for AI-assisted hula workflows.
+ *
+ * Single source of truth: .agents/skills/<name>/SKILL.md (Agent Skills spec).
+ *
+ * Each harness gets a reference to that canonical file:
+ *   - GitHub Copilot, Cursor, Codex, and other Agent Skills-compatible tools
+ *     read directly from .agents/skills/<name>/SKILL.md.
+ *   - Claude Code reads from .claude/commands/<name>.md, which is created as
+ *     a symlink pointing into .agents/skills/ (relative path so it works after
+ *     cloning on any machine). No content is duplicated.
+ *
+ * Because the symlinks are named <name>.md (not SKILL.md) and live under
+ * .claude/commands/ (not .agents/skills/), GitHub Copilot's Agent Skills
+ * scanner does not pick them up, so no duplicate commands appear.
+ *
+ * Any existing .claude/skills/ directory is removed on init to clean up
+ * legacy installations that previously wrote full files there.
+ *
+ * Agent Skills standard: https://agentskills.io/specification
+ */
+async function initializeAgentSkills(projectRoot) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const skillsSourceDir = join(__dirname, '..', 'templates', 'skills');
+    // Canonical location — single source of truth.
+    const agentsSkillsDir = join(projectRoot, '.agents', 'skills');
+    await mkdir(agentsSkillsDir, { recursive: true });
+    // Claude Code reads from .claude/commands/.
+    const claudeCommandsDir = join(projectRoot, '.claude', 'commands');
+    await mkdir(claudeCommandsDir, { recursive: true });
+    // Remove .claude/skills/ if it exists — legacy path that caused duplicates.
+    const claudeSkillsDir = join(projectRoot, '.claude', 'skills');
+    try {
+        await rm(claudeSkillsDir, { recursive: true, force: true });
+    }
+    catch {
+        // Does not exist — nothing to clean up.
+    }
+    for (const { templateDir, skillName } of AGENT_SKILLS) {
+        const srcSkillMd = join(skillsSourceDir, templateDir, 'SKILL.md');
+        // Write the canonical SKILL.md.
+        const agentsDestDir = join(agentsSkillsDir, skillName);
+        await mkdir(agentsDestDir, { recursive: true });
+        await copyFile(srcSkillMd, join(agentsDestDir, 'SKILL.md'));
+        // Create a symlink in .claude/commands/ pointing back to the canonical file.
+        // Relative path so the symlink works after cloning on any machine.
+        const symlinkPath = join(claudeCommandsDir, `${skillName}.md`);
+        const symlinkTarget = join('..', '..', '.agents', 'skills', skillName, 'SKILL.md');
+        // Remove any existing file/symlink before (re-)creating.
+        await rm(symlinkPath, { force: true });
+        await symlink(symlinkTarget, symlinkPath);
+        logger.success(`Updated skill: ${skillName}`);
+    }
+    logger.blank();
+    logger.info('🎉 Agent Skills installed — works with Claude Code, GitHub Copilot, Codex, and 30+ AI tools');
+    logger.info('💡 Invoke with /hula-plan, /hula-fix, /hula-create, etc. (note: hyphens, not dots)');
+}
+/**
+ * List of bundled shell scripts that support the chat participant workflows.
+ * These scripts are copied from src/templates/scripts/ to .github/scripts/
+ * during `hula init` to reduce terminal approval clicks in VS Code.
+ */
+const BUNDLED_SCRIPTS = [
+    'hula-read-config.sh',
+    'hula-fix-setup.sh',
+    'hula-fix-commit.sh',
+    'hula-verify-gather.sh',
+    'hula-verify-post.sh',
+    'hula-merge-local.sh',
+    'hula-merge-remote.sh',
+    'hula-launch-run.sh',
+];
+/**
+ * Initialize bundled shell scripts for chat participant workflows.
+ * Copies scripts from src/templates/scripts/ to .github/scripts/ in the target project.
+ * These scripts bundle multiple terminal commands into single invocations,
+ * reducing VS Code terminal approval popups from ~28 to ~7 per workflow cycle.
+ */
+async function initializeScriptFiles(projectRoot) {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const scriptsSourceDir = join(__dirname, '..', 'templates', 'scripts');
+    const scriptsDestDir = join(projectRoot, '.github', 'scripts');
+    // Create .github/scripts directory
+    await mkdir(scriptsDestDir, { recursive: true });
+    for (const scriptName of BUNDLED_SCRIPTS) {
+        const srcPath = join(scriptsSourceDir, scriptName);
+        const destPath = join(scriptsDestDir, scriptName);
+        // Always overwrite scripts with latest version (they are deterministic tooling, not user-customized)
+        await copyFile(srcPath, destPath);
+        await chmod(destPath, 0o755);
+        logger.success(`Updated script: .github/scripts/${scriptName}`);
+    }
+}
+/**
+ * Recommended VS Code auto-approval patterns for hula agent commands.
+ * These regex patterns match the terminal commands used by hula workflows
+ * so VS Code Copilot Chat won't prompt "Allow" for each one.
+ */
+const VSCODE_AUTO_APPROVE_SETTINGS = {
+    // Hula CLI commands
+    '/^hula\\b/': true,
+    // Git read-only commands
+    '/^git (status|log|diff|fetch|show|branch|worktree list|rev-parse|remote)\\b/': true,
+    // Git write commands used by hula workflows
+    '/^git (add|commit|push|checkout|worktree add|worktree remove)\\b/': true,
+    // GitHub CLI read commands
+    '/^gh (issue view|pr list|pr view|pr diff|repo view)\\b/': true,
+    // GitHub CLI write commands used by hula workflows
+    '/^gh pr (comment|merge)\\b/': true,
+    // Hula bash scripts deployed to .github/scripts/
+    '/^bash \\.github\\/scripts\\/hula-/': true,
+    // Common safe commands
+    '/^(ls|cat|head|tail|wc|echo|mkdir|rm -f|cd|pwd)\\b/': true,
+};
+/**
+ * Initialize VS Code auto-approval settings for hula agent commands.
+ * Creates or deep-merges `.vscode/settings.json` with the auto-approve config.
+ * Preserves all existing settings — only the `chat.tools.terminal.autoApprove` key is touched.
+ */
+async function initVsCodeAutoApproval(projectRoot) {
+    const vscodeDir = join(projectRoot, '.vscode');
+    const settingsPath = join(vscodeDir, 'settings.json');
+    // Ensure .vscode/ directory exists
+    await mkdir(vscodeDir, { recursive: true });
+    let existingSettings = {};
+    if (existsSync(settingsPath)) {
+        try {
+            const raw = await readFile(settingsPath, 'utf-8');
+            // Strip JSON comments (// and /* */) before parsing
+            const stripped = raw
+                .replace(/\/\/.*$/gm, '')
+                .replace(/\/\*[\s\S]*?\*\//g, '');
+            existingSettings = JSON.parse(stripped);
+        }
+        catch {
+            logger.warning('Could not parse existing .vscode/settings.json — creating fresh file');
+            existingSettings = {};
+        }
+    }
+    // Deep-merge: only touch the auto-approve key
+    existingSettings['chat.tools.terminal.autoApprove'] =
+        VSCODE_AUTO_APPROVE_SETTINGS;
+    const content = JSON.stringify(existingSettings, null, 2) + '\n';
+    await writeFile(settingsPath, content, 'utf-8');
+    logger.success('VS Code auto-approval configured: .vscode/settings.json');
+}
+/**
+ * Display current configuration summary
+ */
+function displayConfigSummary(config) {
+    logger.blank();
+    logger.section('Current Configuration');
+    logger.blank();
+    logger.info('📝 Basic Settings:');
+    logger.listItem(`Editor: ${config.editorCommand}`, 1);
+    logger.listItem(`Plan Path: ${config.planPath}`, 1);
+    logger.listItem(`Tracking File: ${config.trackingFile}`, 1);
+    logger.listItem(`Create Issues: ${config.createIssuesPreference}`, 1);
+    logger.listItem(`Plan Choices: ${config.planChoices}`, 1);
+    logger.listItem(`Skip Untracked Prompt: ${config.skipUntrackedPrompt}`, 1);
+    logger.listItem(`Worktree Base Path: ${config.worktreeBasePath ?? '.hula-worktrees'}`, 1);
+    if (config.teamMembers && config.teamMembers.length > 0) {
+        logger.info('👥 Team Members:');
+        config.teamMembers.forEach((member) => logger.listItem(member, 1));
+    }
+    if (config.services) {
+        logger.blank();
+        logger.info('⚙️  Services:');
+        if (config.services.authentication) {
+            logger.listItem(`Auth Provider: ${config.services.authentication.provider}`, 1);
+        }
+    }
+    logger.blank();
+}
+export async function executeInit() {
+    logger.section('Initialize HubLaunch Configuration');
+    // Validate GitHub CLI version
+    logger.info('Checking GitHub CLI version...');
+    const versionValid = await checkGhVersion('2.4.0');
+    if (!versionValid) {
+        logger.error('GitHub CLI version check failed.');
+        logger.error('Please upgrade to continue with initialization.');
+        process.exit(1);
+    }
+    logger.success('✓ GitHub CLI version is sufficient');
+    logger.blank();
+    const repoRoot = await getRepoRoot();
+    const configDir = join(repoRoot, '.hublaunch');
+    const configPath = join(configDir, 'hublaunch.config.js');
+    const configPathTs = join(configDir, 'hublaunch.config.ts');
+    // Load existing config if it exists (check .ts first, then .js)
+    let existingConfig = null;
+    const existingConfigPath = existsSync(configPathTs)
+        ? configPathTs
+        : existsSync(configPath)
+            ? configPath
+            : null;
+    if (existingConfigPath) {
+        logger.info(`📋 Detected existing config: ${relative(repoRoot, existingConfigPath)}`);
+        existingConfig = await parseExistingConfig(existingConfigPath);
+        if (existingConfig) {
+            const preservedKeys = [];
+            if (existingConfig.hulaApiKey)
+                preservedKeys.push('hulaApiKey');
+            if (existingConfig.teamMembers && existingConfig.teamMembers.length > 0)
+                preservedKeys.push('teamMembers');
+            if (existingConfig.anthropicApiKey)
+                preservedKeys.push('anthropicApiKey');
+            if (existingConfig.daytonaApiKey)
+                preservedKeys.push('daytonaApiKey');
+            if (existingConfig.daytonaTier !== undefined)
+                preservedKeys.push('daytonaTier');
+            if (existingConfig.services)
+                preservedKeys.push('services');
+            if (existingConfig.hooks)
+                preservedKeys.push('hooks');
+            if (preservedKeys.length > 0) {
+                logger.success(`✓ Preserved settings: ${preservedKeys.join(', ')}`);
+            }
+            logger.blank();
+        }
+    }
+    // Check if config already exists - proceed with overwrite
+    if (existsSync(configPath)) {
+        logger.info('Configuration file already exists. Proceeding with reinitialization...');
+    }
+    // Helper to convert absolute paths back to relative paths for display/editing
+    const toRelativePath = (absolutePath, defaultPath) => {
+        if (!absolutePath)
+            return defaultPath;
+        if (!isAbsolute(absolutePath))
+            return absolutePath;
+        // Convert absolute path to relative by removing repoRoot prefix
+        const relativePath = relative(repoRoot, absolutePath);
+        return relativePath || defaultPath;
+    };
+    // Display existing config if present
+    // Display existing config if present (for reference)
+    if (existingConfig && existingConfig.planPath) {
+        displayConfigSummary(existingConfig);
+    }
+    else {
+        logger.info("Let's set up your HubLaunch configuration...");
+    }
+    logger.blank();
+    logger.info('📝 Configure ALL settings (use ↑↓ arrows to navigate, Enter to edit each field):');
+    logger.info('💡 Hint: For enum fields, valid values are shown in parentheses');
+    logger.info('💡 Leave fields unchanged to keep current values, or edit to update');
+    logger.blank();
+    // Check if override files exist - only ask about overriding if they exist
+    const startupScriptExists = existsSync(join(repoRoot, '.hublaunch/hooks/deploymentStartupScript.ts'));
+    // Build form choices dynamically - only include override options for files that exist
+    const formChoices = [
+        {
+            name: 'anthropicApiKey',
+            message: 'Anthropic OAuth token (sk-ant-oat01-...) — get it at https://claude.ai/settings',
+            initial: existingConfig?.anthropicApiKey || '',
+        },
+        {
+            name: 'daytonaApiKey',
+            message: 'Daytona API Key (required for hula launch) — get it at https://app.daytona.io',
+            initial: existingConfig?.daytonaApiKey || '',
+        },
+        {
+            name: 'daytonaTier',
+            message: 'Daytona Org Tier (1=Starter, 2=Standard, 3=Pro, 4=Enterprise)',
+            initial: (existingConfig?.daytonaTier ?? 1).toString(),
+            validate: (value) => {
+                const n = parseInt(value, 10);
+                return ([1, 2, 3, 4].includes(n)) || 'Must be 1, 2, 3, or 4';
+            },
+        },
+        {
+            name: 'editorCommand',
+            message: 'Editor (cursor|vsCode|other)',
+            initial: existingConfig?.editorCommand || DEFAULT_CONFIG.editorCommand,
+            validate: (value) => {
+                const valid = ['cursor', 'vsCode', 'other'];
+                return valid.includes(value) || `Must be one of: ${valid.join(', ')}`;
+            },
+        },
+        {
+            name: 'planPath',
+            message: 'Plan files directory',
+            initial: toRelativePath(existingConfig?.planPath, DEFAULT_CONFIG.planPath),
+        },
+        {
+            name: 'trackingFile',
+            message: 'Tracking file path',
+            initial: toRelativePath(existingConfig?.trackingFile, DEFAULT_CONFIG.trackingFile),
+        },
+        {
+            name: 'createIssuesPreference',
+            message: 'Create issues (alwaysLatest|chooseRecentPlan)',
+            initial: existingConfig?.createIssuesPreference ||
+                DEFAULT_CONFIG.createIssuesPreference,
+            validate: (value) => {
+                const valid = ['alwaysLatest', 'chooseRecentPlan'];
+                return valid.includes(value) || `Must be one of: ${valid.join(', ')}`;
+            },
+        },
+        {
+            name: 'planChoices',
+            message: 'Number of recent plans to show',
+            initial: (existingConfig?.planChoices || DEFAULT_CONFIG.planChoices).toString(),
+            validate: (value) => {
+                const num = parseInt(value, 10);
+                return (!isNaN(num) && num > 0) || 'Please enter a positive number';
+            },
+        },
+        {
+            name: 'skipUntrackedPrompt',
+            message: 'Skip untracked prompt (true|false)',
+            initial: (existingConfig?.skipUntrackedPrompt ??
+                DEFAULT_CONFIG.skipUntrackedPrompt).toString(),
+            validate: (value) => {
+                const valid = ['true', 'false', 'yes', 'no'];
+                return valid.includes(value.toLowerCase()) || 'Must be true or false';
+            },
+        },
+        {
+            name: 'teamMembers',
+            message: 'Team members (comma-separated)',
+            initial: existingConfig?.teamMembers?.join(', ') || '',
+        },
+        {
+            name: 'authProvider',
+            message: 'Auth provider (none|clerk|auth0|custom)',
+            initial: existingConfig?.services?.authentication?.provider || 'clerk',
+            validate: (value) => {
+                const valid = ['none', 'clerk', 'auth0', 'custom'];
+                return valid.includes(value) || `Must be one of: ${valid.join(', ')}`;
+            },
+        },
+        {
+            name: 'configureVsCodeAutoApproval',
+            message: 'Configure VS Code auto-approval for hula agent commands? (true|false)',
+            initial: 'true',
+            validate: (value) => {
+                const valid = ['true', 'false', 'yes', 'no'];
+                return valid.includes(value.toLowerCase()) || 'Must be true or false';
+            },
+        },
+    ];
+    // Only add override options for files that already exist
+    if (startupScriptExists) {
+        formChoices.push({
+            name: 'overrideStartupScript',
+            message: 'Override existing deploymentStartupScript.ts? (true|false)',
+            initial: 'false',
+            validate: (value) => {
+                const valid = ['true', 'false', 'yes', 'no'];
+                return valid.includes(value.toLowerCase()) || 'Must be true or false';
+            },
+        });
+    }
+    // Single Unified Form for ALL fields
+    const formData = await form('HubLaunch Configuration', formChoices);
+    // Parse form results with fallbacks
+    const anthropicApiKey = (formData.anthropicApiKey || '').trim() || undefined;
+    const daytonaApiKey = (formData.daytonaApiKey || '').trim() || undefined;
+    const daytonaTier = parseInt(formData.daytonaTier || '1', 10);
+    const editorCommand = (formData.editorCommand ||
+        DEFAULT_CONFIG.editorCommand);
+    const planPath = (formData.planPath || DEFAULT_CONFIG.planPath).replace(/\\/g, '/');
+    const trackingFile = (formData.trackingFile || DEFAULT_CONFIG.trackingFile).replace(/\\/g, '/');
+    const createIssuesPreference = (formData.createIssuesPreference ||
+        DEFAULT_CONFIG.createIssuesPreference);
+    const planChoices = parseInt(formData.planChoices || DEFAULT_CONFIG.planChoices.toString(), 10);
+    const skipUntrackedPrompt = ['true', 'yes'].includes((formData.skipUntrackedPrompt || 'false').toLowerCase());
+    const teamMembers = (formData.teamMembers || '')
+        .split(',')
+        .map((m) => m.trim())
+        .filter((m) => m.length > 0);
+    const authProvider = (formData.authProvider || 'none');
+    // Override defaults to true for new files (they will be created), false for existing
+    const overrideStartupScript = startupScriptExists
+        ? ['true', 'yes'].includes((formData.overrideStartupScript || 'false').toLowerCase())
+        : true;
+    // Parse VS Code auto-approval preference
+    const configureVsCodeAutoApproval = ['true', 'yes'].includes((formData.configureVsCodeAutoApproval || 'true').toLowerCase());
+    // Generate config content
+    const baseConfig = {
+        editorCommand,
+        planPath,
+        trackingFile,
+        createIssuesPreference,
+        planChoices,
+        skipUntrackedPrompt,
+        teamMembers,
+    };
+    // Add services if configured
+    if (authProvider !== 'none') {
+        baseConfig.services = {
+            authentication: {
+                provider: authProvider,
+            },
+        };
+    }
+    // Add hooks if configured
+    if (authProvider !== 'none') {
+        baseConfig.hooks = {
+            deploymentStartup: '.hublaunch/hooks/deploymentStartupScript.ts',
+        };
+    }
+    // Merge with existing config (existing values take precedence)
+    const finalConfig = existingConfig
+        ? mergeConfigs(existingConfig, baseConfig)
+        : baseConfig;
+    // mergeConfigs makes existingConfig win for top-level keys, so assigning to
+    // baseConfig would not let the user clear a previously-saved value. Assign
+    // post-merge so the user's typed value (including cleared) is what gets written.
+    finalConfig.anthropicApiKey = anthropicApiKey;
+    finalConfig.daytonaApiKey = daytonaApiKey;
+    finalConfig.daytonaTier = daytonaTier;
+    // Generate hooks config section
+    let hooksConfigSection;
+    if (finalConfig.hooks) {
+        hooksConfigSection = `
+  // Lifecycle hooks
+  hooks: ${JSON.stringify(finalConfig.hooks, null, 2).replace(/\n/g, '\n  ')},`;
+    }
+    else {
+        hooksConfigSection = `
+  // Lifecycle hooks (optional)
+  // hooks: {
+  //   deploymentStartup: ".hublaunch/hooks/deploymentStartupScript.ts",
+  // },`;
+    }
+    // Generate services config section (without credentials)
+    let servicesConfigSection;
+    if (finalConfig.services) {
+        servicesConfigSection = `
+  // Service configuration
+  services: ${JSON.stringify(finalConfig.services, null, 2).replace(/\n/g, '\n  ')},`;
+    }
+    else {
+        servicesConfigSection = `
+  // Service configuration (optional)
+  // services: {
+  //   authentication: { provider: "none" },
+  // },`;
+    }
+    // Generate config content with preserved API key
+    const apiKeyLine = finalConfig.hulaApiKey
+        ? `\n  hulaApiKey: "${finalConfig.hulaApiKey}",`
+        : '\n  // hulaApiKey: "your-api-key-here",';
+    const anthropicKeyLine = finalConfig.anthropicApiKey
+        ? `\n  anthropicApiKey: "${finalConfig.anthropicApiKey}",`
+        : '\n  // anthropicApiKey: "",  // Anthropic OAuth token (sk-ant-oat01-...) — get it at https://claude.ai/settings (requires a paid Claude.ai plan — Pro or Max)';
+    const daytonaKeyLine = finalConfig.daytonaApiKey
+        ? `\n  daytonaApiKey: "${finalConfig.daytonaApiKey}",`
+        : '\n  // daytonaApiKey: "",  // Daytona API key — get your key at https://app.daytona.io (or set DAYTONA_API_KEY env var)';
+    const daytonaTierLine = `\n  daytonaTier: ${finalConfig.daytonaTier ?? 1},  // Daytona org tier (1–4). Tier 1=Starter, 2=Standard, 3=Pro, 4=Enterprise. Override with --daytona-tier or DAYTONA_TIER env var.`;
+    const containerResourcesLine = finalConfig.containerResources
+        ? `\n  containerResources: { ${[
+            finalConfig.containerResources.cpu !== undefined ? `cpu: ${finalConfig.containerResources.cpu}` : null,
+            finalConfig.containerResources.memory !== undefined ? `memory: ${finalConfig.containerResources.memory}` : null,
+            finalConfig.containerResources.disk !== undefined ? `disk: ${finalConfig.containerResources.disk}` : null,
+        ].filter(Boolean).join(', ')} },  // Per-sandbox resource override (cpu: 1–32, memory: 1–128 GiB, disk: 5–200 GiB). Override per-task with --container-cpu/memory/disk flags.`
+        : '\n  containerResources: { cpu: 2, memory: 8, disk: 10 },  // Per-sandbox resource override (cpu: 1–32, memory: 1–128 GiB, disk: 5–200 GiB). Override per-task with --container-cpu/memory/disk flags.';
+    const updateNotificationUrlLine = finalConfig.updateNotificationUrl
+        ? `\n  updateNotificationUrl: "${finalConfig.updateNotificationUrl}",`
+        : '\n  // updateNotificationUrl: "https://hooks.slack.com/services/T0/B0/secret",  // POSTed on every terminal task transition (Slack hosts get { text } body, others get generic JSON). See hula-server API.md.';
+    const configContent = `export const config = {
+  // API Configuration${apiKeyLine}${anthropicKeyLine}${daytonaKeyLine}${daytonaTierLine}${containerResourcesLine}${updateNotificationUrlLine}
+
+  // Editor configuration
+  editorCommand: "${finalConfig.editorCommand || editorCommand}",
+
+  // Plan files configuration
+  planPath: "${finalConfig.planPath || planPath}",
+  trackingFile: "${finalConfig.trackingFile || trackingFile}",
+  createIssuesPreference: "${finalConfig.createIssuesPreference || createIssuesPreference}",
+  planChoices: ${finalConfig.planChoices ?? planChoices},
+
+  // Tracking behavior
+  skipUntrackedPrompt: ${finalConfig.skipUntrackedPrompt ?? skipUntrackedPrompt},
+
+  // Polling / auto-refresh
+  pollingProvider: "${finalConfig.pollingProvider || 'hula-server'}",  // "hula-server" | "github"
+  pollIntervalSeconds: ${finalConfig.pollIntervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS},  // Minimum 60
+
+  // Team members${finalConfig.teamMembers && finalConfig.teamMembers.length > 0
+        ? `\n  teamMembers: ${JSON.stringify(finalConfig.teamMembers)},`
+        : '\n  // teamMembers: [],'}
+
+  // Command aliases (optional)
+  // commandAliases: {
+  //   primary: ["hula", "hub-launch", "hl"],
+  // },
+
+  // Priority levels (optional)
+  // priorityLevels: [
+  //   { name: "Critical", color: "red", emoji: "🔴" },
+  //   { name: "High", color: "orange", emoji: "🟠" },
+  //   { name: "Medium", color: "yellow", emoji: "🟡" },
+  //   { name: "Low", color: "green", emoji: "🟢" },
+  //   { name: "Minimal", color: "gray", emoji: "⚪" },
+  // ],
+
+  // Issue sorting (optional)
+  // issueSortOrder: {
+  //   groupBy: "priority",
+  //   sortBy: "created",
+  //   direction: "desc",
+  // },
+${servicesConfigSection}
+${hooksConfigSection}
+
+  // Browser automation
+  browserHeadless: "auto",  // "auto" | "always" | "never"
+
+  // Worktree base path (used by /hula-fix, /hula-merge, /hula-upload)
+  worktreeBasePath: "${(finalConfig.worktreeBasePath || '.hula-worktrees').replace(/\\/g, '\\\\').replace(/"/g, '\\"')}",
+};
+`;
+    // Create directory if it doesn't exist
+    if (!existsSync(configDir)) {
+        await mkdir(configDir, { recursive: true });
+    }
+    // Create plans directory if it doesn't exist
+    const plansDir = join(repoRoot, planPath);
+    if (!existsSync(plansDir)) {
+        await mkdir(plansDir, { recursive: true });
+        logger.success(`Created plans directory: ${planPath}`);
+    }
+    // Create worktrees directory if it doesn't exist
+    const worktreeBasePath = finalConfig.worktreeBasePath || '.hula-worktrees';
+    const worktreesDir = isAbsolute(worktreeBasePath)
+        ? worktreeBasePath
+        : join(repoRoot, worktreeBasePath);
+    if (!existsSync(worktreesDir)) {
+        await mkdir(worktreesDir, { recursive: true });
+        logger.success(`Created worktrees directory: ${worktreeBasePath}`);
+    }
+    // Write config file
+    await writeFile(configPath, configContent, 'utf-8');
+    logger.blank();
+    logger.success(`✨ Configuration created: ${configPath}`);
+    // Add hublaunch.config.js to .gitignore
+    const gitignorePath = join(repoRoot, '.gitignore');
+    try {
+        let gitignoreContent = '';
+        if (existsSync(gitignorePath)) {
+            gitignoreContent = await import('fs/promises').then((fs) => fs.readFile(gitignorePath, 'utf-8'));
+        }
+        // Check if hublaunch.config.js is already in .gitignore
+        if (!gitignoreContent.includes('hublaunch.config.js')) {
+            // Add entry with comment
+            const newEntry = gitignoreContent.endsWith('\n')
+                ? '# HubLaunch configuration\nhublaunch.config.js\n'
+                : '\n# HubLaunch configuration\nhublaunch.config.js\n';
+            gitignoreContent += newEntry;
+            await import('fs/promises').then((fs) => fs.writeFile(gitignorePath, gitignoreContent, 'utf-8'));
+            logger.success('✨ Added hublaunch.config.js to .gitignore');
+        }
+        // Check if worktree base path is already in .gitignore (skip absolute paths — they're outside the repo)
+        if (!isAbsolute(worktreeBasePath) &&
+            !gitignoreContent.includes(worktreeBasePath)) {
+            gitignoreContent += `\n# HubLaunch worktrees\n${worktreeBasePath}/\n`;
+            await import('fs/promises').then((fs) => fs.writeFile(gitignorePath, gitignoreContent, 'utf-8'));
+            logger.success(`✨ Added ${worktreeBasePath}/ to .gitignore`);
+        }
+        // Warn if .agents/skills is in .gitignore — it must be committed so all
+        // team members get GitHub Copilot and Claude Code support.
+        if (gitignoreContent.includes('.agents/skills')) {
+            logger.warning('⚠️  .agents/skills is listed in .gitignore — this will prevent GitHub Copilot and Claude Code from finding skills.');
+            logger.warning('   Remove ".agents/skills" from .gitignore to allow the skills directory to be committed.');
+        }
+    }
+    catch (error) {
+        logger.warning(`Could not update .gitignore: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    // Create .env template file with instructions (no credentials) in project root
+    const envPath = join(process.cwd(), '.env');
+    const envLines = [
+        '# HubLaunch Environment Variables',
+        '# This file contains sensitive credentials and should NOT be committed to version control',
+        '# It is automatically added to .gitignore',
+        '',
+    ];
+    // Add credential templates based on selected services
+    if (authProvider !== 'none') {
+        envLines.push('# Authentication credentials for preview automation');
+        envLines.push('TEST_USER_EMAIL=test@example.com');
+        envLines.push('TEST_USER_PASSWORD=your_test_password');
+        envLines.push('');
+    }
+    // Only create .env file if it doesn't exist
+    if (!existsSync(envPath)) {
+        await writeFile(envPath, envLines.join('\n'), 'utf-8');
+        logger.success(`✨ Template .env file created: ${envPath}`);
+        logger.warning('⚠️  Remember: Never commit .env files to version control!');
+    }
+    else {
+        logger.info(`ℹ️  .env file already exists at ${envPath} - skipping to preserve your existing configuration`);
+        logger.info('   Add any required environment variables manually if needed');
+    }
+    // Always generate hooks directory structure (with README and optionally script)
+    logger.blank();
+    logger.info('Generating hooks directory structure...');
+    await generateHookTemplates(repoRoot, authProvider, overrideStartupScript);
+    // Always generate adapters directory structure
+    logger.blank();
+    logger.info('Generating adapter directory structure...');
+    await generateAdapterStructure(repoRoot);
+    // Always generate templates directory structure
+    logger.blank();
+    logger.info('Generating templates directory structure...');
+    await generateTemplatesStructure(repoRoot);
+    // Copy planning instruction templates to .hublaunch/ for skills to reference at runtime
+    logger.blank();
+    logger.info('Updating planning instruction templates...');
+    await initializePlanningInstructions(repoRoot, true, true);
+    // Initialize Agent Skills for AI-assisted planning (works with Copilot, Claude Code, and others)
+    logger.blank();
+    logger.info('Setting up Agent Skills for AI-assisted planning...');
+    await initializeAgentSkills(repoRoot);
+    // Initialize bundled shell scripts for chat participant workflows
+    logger.blank();
+    logger.info('Setting up bundled shell scripts for chat workflows...');
+    await initializeScriptFiles(repoRoot);
+    // Configure VS Code auto-approval for hula agent commands
+    if (configureVsCodeAutoApproval) {
+        logger.blank();
+        logger.info('Configuring VS Code auto-approval for hula agent commands...');
+        await initVsCodeAutoApproval(repoRoot);
+    }
+    logger.blank();
+    logger.blank();
+    logger.info('Next steps:');
+    logger.listItem('Review and customize the configuration if needed', 1);
+    // Show credential setup instructions based on selected services
+    if (authProvider !== 'none') {
+        logger.listItem('⚠️  Configure credentials in .env file at project root:', 1);
+        logger.listItem('- TEST_USER_EMAIL: Test user email for preview automation', 2);
+        logger.listItem('- TEST_USER_PASSWORD: Test user password', 2);
+        logger.blank();
+    }
+    if (authProvider !== 'none') {
+        logger.listItem('Customize .hublaunch/hooks/deploymentStartupScript.ts as needed', 1);
+    }
+    logger.listItem('Create issue plan files in the plans directory', 1);
+    logger.listItem("Run 'hublaunch create' to create your first issue", 1);
+    logger.blank();
+    logger.info('💡 Or use the Agent Skills slash commands in any AI chat:');
+    logger.info('   - /hula-plan <description> - Generate implementation plan');
+    logger.info('   - /hula-confirm - Validate and refine the plan');
+    logger.info('   - /hula-upload - Upload plan to origin/main');
+    logger.info('   - /hula-launch <branch> - Launch issue from plan');
+    logger.info('   - /hula-create <name> [--handoff <user>] [--priority <level>] - Create GitHub issue');
+    logger.info('   - /hula-fix <problem> - Fix issues on PR branch');
+    logger.info('   - /hula-verify [issue] - Verify implementation against plan');
+    logger.info('   - /hula-merge - Merge PR and restore original branch');
+    logger.info('   - /hula-log [issueName] - View job logs in editor');
+    logger.blank();
+    logger.info('💡 These skills work with GitHub Copilot (VS Code), Claude Code, and other Agent Skills-compatible tools.');
+}
+//# sourceMappingURL=init.js.map