humanbehavior-js 0.7.0 → 0.7.1

package/packages/wizard/dist/cli/ai-auto-install.js

@@ -1,1890 +1,621 @@
 #!/usr/bin/env node
+import * as clack from '@clack/prompts';
 import * as fs from 'fs';
 import * as path from 'path';
-import { execSync } from 'child_process';
-import * as clack from '@clack/prompts';
+import { exec } from 'child_process';
+import { promisify } from 'util';
 
-/**
- * HumanBehavior SDK Auto-Installation Wizard
- *
- * This wizard automatically detects the user's framework and modifies their codebase
- * to integrate the SDK with minimal user intervention.
- */
-class AutoInstallationWizard {
-    constructor(apiKey, projectRoot = process.cwd()) {
-        this.framework = null;
-        this.manualNotes = [];
-        this.apiKey = apiKey;
-        this.projectRoot = projectRoot;
-    }
-    /**
-     * Simple version comparison utility
-     */
-    compareVersions(version1, version2) {
-        const v1Parts = version1.split('.').map(Number);
-        const v2Parts = version2.split('.').map(Number);
-        for (let i = 0; i < Math.max(v1Parts.length, v2Parts.length); i++) {
-            const v1 = v1Parts[i] || 0;
-            const v2 = v2Parts[i] || 0;
-            if (v1 > v2)
-                return 1;
-            if (v1 < v2)
-                return -1;
-        }
-        return 0;
-    }
-    isVersionGte(version, target) {
-        return this.compareVersions(version, target) >= 0;
-    }
-    getMajorVersion(version) {
-        return parseInt(version.split('.')[0]) || 0;
-    }
-    /**
-     * Main installation method - detects framework and auto-installs
-     */
-    async install() {
+const execAsync = promisify(exec);
+const MAX_READ_BYTES = 24000;
+const MAX_SEARCH_RESULTS = 40;
+const MAX_BASH_OUTPUT = 24000;
+const VERIFY_EVENT = '$humanbehavior_wizard_verified';
+const DEFAULT_INGESTION_URL = 'https://ingest.humanbehavior.co';
+class LocalToolExecutor {
+    constructor(projectRoot, verification) {
+        this.projectRoot = path.resolve(projectRoot);
+        this.verification = verification;
+    }
+    async execute(request) {
         try {
-            // Step 1: Detect framework
-            this.framework = await this.detectFramework();
-            // Step 2: Install package
-            await this.installPackage();
-            // Step 3: Generate and apply code modifications
-            const modifications = await this.generateModifications();
-            await this.applyModifications(modifications);
-            // Step 4: Generate next steps
-            const nextSteps = this.generateNextSteps();
+            let content;
+            switch (request.name) {
+                case 'hb_list_files':
+                    content = this.listFiles(request.input);
+                    break;
+                case 'hb_read_file':
+                    content = this.readFile(request.input);
+                    break;
+                case 'hb_write_file':
+                    content = this.writeFile(request.input);
+                    break;
+                case 'hb_grep':
+                    content = this.grep(request.input);
+                    break;
+                case 'hb_bash':
+                    content = await this.bash(request.input);
+                    break;
+                case 'hb_verify_installation':
+                    content = await this.verifyInstallation();
+                    break;
+                default:
+                    throw new Error(`Unknown tool: ${request.name}`);
+            }
             return {
-                success: true,
-                framework: this.framework,
-                modifications,
-                errors: [],
-                nextSteps
+                type: 'tool_result',
+                tool_use_id: request.id,
+                content
             };
         }
         catch (error) {
             return {
-                success: false,
-                framework: this.framework || { name: 'unknown', type: 'vanilla' },
-                modifications: [],
-                errors: [error instanceof Error ? error.message : 'Unknown error'],
-                nextSteps: []
+                type: 'tool_result',
+                tool_use_id: request.id,
+                content: error instanceof Error ? error.message : 'Unknown tool error',
+                is_error: true
             };
         }
     }
-    /**
-     * Detect the current framework and project setup
-     */
-    async detectFramework() {
-        const packageJsonPath = path.join(this.projectRoot, 'package.json');
-        if (!fs.existsSync(packageJsonPath)) {
-            return {
-                name: 'vanilla',
-                type: 'vanilla',
-                projectRoot: this.projectRoot
-            };
-        }
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        const dependencies = {
-            ...packageJson.dependencies,
-            ...packageJson.devDependencies
-        };
-        // Detect framework with version information
-        let framework = {
-            name: 'vanilla',
-            type: 'vanilla',
-            projectRoot: this.projectRoot,
-            features: {}
+    resolveProjectPath(inputPath) {
+        const relativePath = typeof inputPath === 'string' && inputPath.trim() ? inputPath : '.';
+        const resolved = path.resolve(this.projectRoot, relativePath);
+        if (resolved !== this.projectRoot && !resolved.startsWith(`${this.projectRoot}${path.sep}`)) {
+            throw new Error(`Path escapes project root: ${relativePath}`);
+        }
+        return resolved;
+    }
+    listFiles(input) {
+        const start = this.resolveProjectPath(input.path);
+        const maxDepth = typeof input.maxDepth === 'number' ? Math.max(0, Math.min(input.maxDepth, 6)) : 3;
+        const ignored = new Set(['.git', '.next', 'dist', 'build', 'coverage', 'node_modules']);
+        const results = [];
+        const visit = (dir, depth) => {
+            if (depth > maxDepth || results.length >= 300)
+                return;
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (ignored.has(entry.name) || entry.name.endsWith('-lock.json') || entry.name === 'pnpm-lock.yaml' || entry.name === 'yarn.lock')
+                    continue;
+                const fullPath = path.join(dir, entry.name);
+                const relative = path.relative(this.projectRoot, fullPath) || '.';
+                results.push(entry.isDirectory() ? `${relative}/` : relative);
+                if (entry.isDirectory())
+                    visit(fullPath, depth + 1);
+                if (results.length >= 120)
+                    break;
+            }
         };
-        if (dependencies.nuxt) {
-            const nuxtVersion = dependencies.nuxt;
-            const isNuxt3 = this.isVersionGte(nuxtVersion, '3.0.0');
-            framework = {
-                name: 'nuxt',
-                type: 'nuxt',
-                version: nuxtVersion,
-                majorVersion: this.getMajorVersion(nuxtVersion),
-                hasTypeScript: !!dependencies.typescript,
-                hasRouter: true,
-                projectRoot: this.projectRoot,
-                features: {
-                    hasNuxt3: isNuxt3
-                }
-            };
-        }
-        else if (dependencies.next) {
-            const nextVersion = dependencies.next;
-            const isNext13 = this.isVersionGte(nextVersion, '13.0.0');
-            framework = {
-                name: 'nextjs',
-                type: 'nextjs',
-                version: nextVersion,
-                majorVersion: this.getMajorVersion(nextVersion),
-                hasTypeScript: !!dependencies.typescript || !!dependencies['@types/node'],
-                hasRouter: true,
-                projectRoot: this.projectRoot,
-                features: {
-                    hasNextAppRouter: isNext13
-                }
-            };
-        }
-        else if (dependencies['@remix-run/react'] || dependencies['@remix-run/dev']) {
-            const remixVersion = dependencies['@remix-run/react'] || dependencies['@remix-run/dev'];
-            framework = {
-                name: 'remix',
-                type: 'remix',
-                version: remixVersion,
-                majorVersion: this.getMajorVersion(remixVersion),
-                hasTypeScript: !!dependencies.typescript || !!dependencies['@types/react'],
-                hasRouter: true,
-                projectRoot: this.projectRoot,
-                features: {}
-            };
-        }
-        else if (dependencies.react) {
-            const reactVersion = dependencies.react;
-            const isReact18 = this.isVersionGte(reactVersion, '18.0.0');
-            framework = {
-                name: 'react',
-                type: 'react',
-                version: reactVersion,
-                majorVersion: this.getMajorVersion(reactVersion),
-                hasTypeScript: !!dependencies.typescript || !!dependencies['@types/react'],
-                hasRouter: !!dependencies['react-router-dom'] || !!dependencies['react-router'],
-                projectRoot: this.projectRoot,
-                features: {
-                    hasReact18: isReact18
-                }
-            };
-        }
-        else if (dependencies.vue) {
-            const vueVersion = dependencies.vue;
-            const isVue3 = this.isVersionGte(vueVersion, '3.0.0');
-            framework = {
-                name: 'vue',
-                type: 'vue',
-                version: vueVersion,
-                majorVersion: this.getMajorVersion(vueVersion),
-                hasTypeScript: !!dependencies.typescript || !!dependencies['@vue/cli-service'],
-                hasRouter: !!dependencies['vue-router'],
-                projectRoot: this.projectRoot,
-                features: {
-                    hasVue3: isVue3
-                }
-            };
-        }
-        else if (dependencies['@angular/core']) {
-            const angularVersion = dependencies['@angular/core'];
-            const isAngular17 = this.isVersionGte(angularVersion, '17.0.0');
-            framework = {
-                name: 'angular',
-                type: 'angular',
-                version: angularVersion,
-                majorVersion: this.getMajorVersion(angularVersion),
-                hasTypeScript: true,
-                hasRouter: true,
-                projectRoot: this.projectRoot,
-                features: {
-                    hasAngularStandalone: isAngular17
+        visit(start, 0);
+        return results.slice(0, 120).join('\n') || '(no files)';
+    }
+    readFile(input) {
+        const filePath = this.resolveProjectPath(input.path);
+        const maxBytes = typeof input.maxBytes === 'number'
+            ? Math.max(1, Math.min(input.maxBytes, MAX_READ_BYTES))
+            : MAX_READ_BYTES;
+        const buffer = fs.readFileSync(filePath);
+        const truncated = buffer.length > maxBytes;
+        const content = buffer.subarray(0, maxBytes).toString('utf8');
+        return truncated ? `${content}\n\n[truncated at ${maxBytes} bytes]` : content;
+    }
+    writeFile(input) {
+        if (typeof input.content !== 'string') {
+            throw new Error('content must be a string');
+        }
+        const filePath = this.resolveProjectPath(input.path);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, input.content, 'utf8');
+        return `Wrote ${Buffer.byteLength(input.content, 'utf8')} bytes to ${path.relative(this.projectRoot, filePath)}`;
+    }
+    grep(input) {
+        if (typeof input.pattern !== 'string' || !input.pattern) {
+            throw new Error('pattern is required');
+        }
+        const root = this.resolveProjectPath(input.path);
+        const regex = new RegExp(input.pattern, 'i');
+        const ignored = new Set(['.git', '.next', 'dist', 'build', 'coverage', 'node_modules']);
+        const results = [];
+        const visit = (target) => {
+            if (results.length >= MAX_SEARCH_RESULTS)
+                return;
+            const stat = fs.statSync(target);
+            if (stat.isDirectory()) {
+                for (const entry of fs.readdirSync(target, { withFileTypes: true })) {
+                    if (ignored.has(entry.name) || entry.name.endsWith('-lock.json') || entry.name === 'pnpm-lock.yaml' || entry.name === 'yarn.lock')
+                        continue;
+                    visit(path.join(target, entry.name));
+                    if (results.length >= MAX_SEARCH_RESULTS)
+                        break;
                 }
-            };
-        }
-        else if (dependencies.svelte) {
-            const svelteVersion = dependencies.svelte;
-            const isSvelteKit = !!dependencies['@sveltejs/kit'];
-            framework = {
-                name: 'svelte',
-                type: 'svelte',
-                version: svelteVersion,
-                majorVersion: this.getMajorVersion(svelteVersion),
-                hasTypeScript: !!dependencies.typescript || !!dependencies['svelte-check'],
-                hasRouter: !!dependencies['svelte-routing'] || !!dependencies['@sveltejs/kit'],
-                projectRoot: this.projectRoot,
-                features: {
-                    hasSvelteKit: isSvelteKit
+                return;
+            }
+            if (!stat.isFile() || stat.size > 512000)
+                return;
+            const text = fs.readFileSync(target, 'utf8');
+            const lines = text.split(/\r?\n/);
+            for (let index = 0; index < lines.length; index++) {
+                if (regex.test(lines[index])) {
+                    const line = lines[index].length > 240 ? `${lines[index].slice(0, 240)}...` : lines[index];
+                    results.push(`${path.relative(this.projectRoot, target)}:${index + 1}: ${line}`);
+                    if (results.length >= MAX_SEARCH_RESULTS)
+                        break;
                 }
-            };
-        }
-        else if (dependencies.astro) {
-            const astroVersion = dependencies.astro;
-            framework = {
-                name: 'astro',
-                type: 'astro',
-                version: astroVersion,
-                majorVersion: this.getMajorVersion(astroVersion),
-                hasTypeScript: !!dependencies.typescript || !!dependencies['@astrojs/ts-plugin'],
-                hasRouter: true,
-                projectRoot: this.projectRoot,
-                features: {}
-            };
-        }
-        else if (dependencies.gatsby) {
-            const gatsbyVersion = dependencies.gatsby;
-            framework = {
-                name: 'gatsby',
-                type: 'gatsby',
-                version: gatsbyVersion,
-                majorVersion: this.getMajorVersion(gatsbyVersion),
-                hasTypeScript: !!dependencies.typescript || !!dependencies['@types/react'],
-                hasRouter: true,
-                projectRoot: this.projectRoot,
-                features: {}
-            };
-        }
-        // Detect bundler
-        if (dependencies.vite) {
-            framework.bundler = 'vite';
-        }
-        else if (dependencies.webpack) {
-            framework.bundler = 'webpack';
-        }
-        else if (dependencies.esbuild) {
-            framework.bundler = 'esbuild';
-        }
-        else if (dependencies.rollup) {
-            framework.bundler = 'rollup';
-        }
-        // Detect package manager
-        if (fs.existsSync(path.join(this.projectRoot, 'yarn.lock'))) {
-            framework.packageManager = 'yarn';
-        }
-        else if (fs.existsSync(path.join(this.projectRoot, 'pnpm-lock.yaml'))) {
-            framework.packageManager = 'pnpm';
-        }
-        else {
-            framework.packageManager = 'npm';
-        }
-        return framework;
-    }
-    /**
-     * Install the SDK package with latest version range
-     */
-    async installPackage() {
-        // Build base command with latest version range
-        let command = this.framework?.packageManager === 'yarn'
-            ? 'yarn add humanbehavior-js@latest'
-            : this.framework?.packageManager === 'pnpm'
-                ? 'pnpm add humanbehavior-js@latest'
-                : 'npm install humanbehavior-js@latest';
-        // Add legacy peer deps flag for npm to handle dependency conflicts
-        if (this.framework?.packageManager !== 'yarn' && this.framework?.packageManager !== 'pnpm') {
-            command += ' --legacy-peer-deps';
-        }
-        try {
-            execSync(command, { cwd: this.projectRoot, stdio: 'inherit' });
-        }
-        catch (error) {
-            throw new Error(`Failed to install humanbehavior-js: ${error}`);
-        }
-    }
-    /**
-     * Generate code modifications based on framework
-     */
-    async generateModifications() {
-        const modifications = [];
-        switch (this.framework?.type) {
-            case 'react':
-                modifications.push(...await this.generateReactModifications());
-                break;
-            case 'nextjs':
-                modifications.push(...await this.generateNextJSModifications());
-                break;
-            case 'nuxt':
-                modifications.push(...await this.generateNuxtModifications());
-                break;
-            case 'astro':
-                modifications.push(...await this.generateAstroModifications());
-                break;
-            case 'gatsby':
-                modifications.push(...await this.generateGatsbyModifications());
-                break;
-            case 'remix':
-                modifications.push(...await this.generateRemixModifications());
-                break;
-            case 'vue':
-                modifications.push(...await this.generateVueModifications());
-                break;
-            case 'angular':
-                modifications.push(...await this.generateAngularModifications());
-                break;
-            case 'svelte':
-                modifications.push(...await this.generateSvelteModifications());
-                break;
-            default:
-                modifications.push(...await this.generateVanillaModifications());
-        }
-        return modifications;
-    }
-    /**
-     * Generate React-specific modifications
-     */
-    async generateReactModifications() {
-        const modifications = [];
-        // Find main App component or index file
-        const appFile = this.findReactAppFile();
-        if (appFile) {
-            const content = fs.readFileSync(appFile, 'utf8');
-            const modifiedContent = this.injectReactProvider(content, appFile);
-            modifications.push({
-                filePath: appFile,
-                action: 'modify',
-                content: modifiedContent,
-                description: 'Added HumanBehaviorProvider to React app'
-            });
-        }
-        // Create or append to environment file
-        modifications.push(this.createEnvironmentModification(this.framework));
-        return modifications;
-    }
-    /**
-     * Helper: Merge HBProvider into existing providers.tsx file
-     */
-    mergeProvidersFile(filePath) {
-        const hbProviderContent = `export function HBProvider({ children }: { children: React.ReactNode }) {
-  return (
-    <HumanBehaviorProvider apiKey={process.env.NEXT_PUBLIC_HUMANBEHAVIOR_API_KEY}>
-      {children}
-    </HumanBehaviorProvider>
-  );
-}`;
-        if (!fs.existsSync(filePath)) {
-            // File doesn't exist, create new file
-            return `'use client';
-
-import { HumanBehaviorProvider } from 'humanbehavior-js/react';
-
-${hbProviderContent}`;
-        }
-        // File exists, read and merge
-        const existingContent = fs.readFileSync(filePath, 'utf8');
-        // Check if HBProvider already exists
-        if (existingContent.includes('export function HBProvider') || existingContent.includes('export const HBProvider')) {
-            // Already exists, return unchanged
-            return existingContent;
-        }
-        // Check if HumanBehaviorProvider import exists
-        let modifiedContent = existingContent;
-        if (!existingContent.includes("from 'humanbehavior-js/react'")) {
-            // Add the import - try to add after 'use client' or at the top
-            if (existingContent.includes("'use client'")) {
-                modifiedContent = existingContent.replace(/('use client';?)\s*\n/, `$1\n\nimport { HumanBehaviorProvider } from 'humanbehavior-js/react';\n`);
             }
-            else {
-                // Add at the top
-                modifiedContent = `import { HumanBehaviorProvider } from 'humanbehavior-js/react';\n\n${existingContent}`;
+        };
+        visit(root);
+        return results.join('\n') || '(no matches)';
+    }
+    async bash(input) {
+        if (typeof input.command !== 'string' || !input.command.trim()) {
+            throw new Error('command is required');
+        }
+        this.assertSafeCommand(input.command);
+        const { stdout, stderr } = await execAsync(input.command, {
+            cwd: this.projectRoot,
+            timeout: 60000,
+            maxBuffer: MAX_BASH_OUTPUT,
+            env: process.env
+        });
+        const output = [stdout, stderr].filter(Boolean).join('\n');
+        if (!output)
+            return '(command completed with no output)';
+        return output.length > MAX_BASH_OUTPUT
+            ? `${output.slice(0, MAX_BASH_OUTPUT)}\n\n[truncated at ${MAX_BASH_OUTPUT} bytes]`
+            : output;
+    }
+    async verifyInstallation() {
+        if (!this.verification) {
+            throw new Error('Verification is not configured for this run.');
+        }
+        const sessionId = `hb-wizard-${this.verification.runId}`;
+        const endUserId = `hb-wizard-${this.verification.runId}`;
+        const ingestionUrl = (this.verification.ingestionUrl || process.env.HUMANBEHAVIOR_INGESTION_URL || DEFAULT_INGESTION_URL).replace(/\/$/, '');
+        const response = await fetch(`${ingestionUrl}/api/ingestion/customEvent`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${this.verification.apiKey}`
+            },
+            body: JSON.stringify({
+                sessionId,
+                endUserId,
+                eventName: VERIFY_EVENT,
+                eventProperties: {
+                    wizardRunId: this.verification.runId,
+                    source: 'humanbehavior-wizard',
+                    projectRoot: this.projectRoot
+                },
+                automaticProperties: {
+                    url: 'humanbehavior://wizard',
+                    pathname: '/wizard'
+                }
+            })
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => response.statusText);
+            throw new Error(`Verification event failed (${response.status}): ${body || response.statusText}`);
+        }
+        for (let attempt = 1; attempt <= 12; attempt++) {
+            const verification = await this.verification.verifyRun();
+            if (verification.verified) {
+                return JSON.stringify({
+                    verified: true,
+                    event: VERIFY_EVENT,
+                    attempt,
+                    verification: verification.verification ?? {}
+                });
             }
+            await new Promise((resolve) => setTimeout(resolve, 2500));
         }
-        // Add HBProvider export at the end
-        // Ensure there's proper spacing before adding the export
-        const trimmed = modifiedContent.trimEnd();
-        if (trimmed === '') {
-            // File is empty (after trimming trailing whitespace)
-            modifiedContent = hbProviderContent;
-        }
-        else {
-            // Add double newline for separation
-            modifiedContent = `${trimmed}\n\n${hbProviderContent}`;
-        }
-        return modifiedContent;
-    }
-    /**
-     * Generate Next.js-specific modifications
-     */
-    async generateNextJSModifications() {
-        const modifications = [];
-        // Check for App Router - try both with and without src directory
-        const appLayoutFileWithSrc = path.join(this.projectRoot, 'src', 'app', 'layout.tsx');
-        const appLayoutFile = path.join(this.projectRoot, 'app', 'layout.tsx');
-        const pagesLayoutFileWithSrc = path.join(this.projectRoot, 'src', 'pages', '_app.tsx');
-        const pagesLayoutFile = path.join(this.projectRoot, 'pages', '_app.tsx');
-        // Determine which layout file exists and set paths accordingly
-        let actualAppLayoutFile = null;
-        let providersFilePath = null;
-        let providersImportPath = null;
-        if (fs.existsSync(appLayoutFileWithSrc)) {
-            actualAppLayoutFile = appLayoutFileWithSrc;
-            providersFilePath = path.join(this.projectRoot, 'src', 'app', 'providers.tsx');
-            providersImportPath = '@/app/providers';
-        }
-        else if (fs.existsSync(appLayoutFile)) {
-            actualAppLayoutFile = appLayoutFile;
-            providersFilePath = path.join(this.projectRoot, 'app', 'providers.tsx');
-            providersImportPath = '@/app/providers';
-        }
-        if (actualAppLayoutFile) {
-            // Merge or create providers.tsx file
-            const providersContent = this.mergeProvidersFile(providersFilePath);
-            const fileExists = fs.existsSync(providersFilePath);
-            modifications.push({
-                filePath: providersFilePath,
-                action: fileExists ? 'modify' : 'create',
-                content: providersContent,
-                description: fileExists
-                    ? 'Merged HBProvider into existing providers.tsx file'
-                    : 'Created providers.tsx file with HBProvider for Next.js App Router'
-            });
-            // Modify layout.tsx to use the provider
-            const content = fs.readFileSync(actualAppLayoutFile, 'utf8');
-            const modifiedContent = this.injectNextJSAppRouter(content, providersImportPath);
-            modifications.push({
-                filePath: actualAppLayoutFile,
-                action: 'modify',
-                content: modifiedContent,
-                description: 'Added HumanBehavior provider wrapper to Next.js App Router layout'
-            });
-        }
-        else if (fs.existsSync(pagesLayoutFileWithSrc) || fs.existsSync(pagesLayoutFile)) {
-            const actualPagesLayoutFile = fs.existsSync(pagesLayoutFileWithSrc) ? pagesLayoutFileWithSrc : pagesLayoutFile;
-            const providersPath = fs.existsSync(pagesLayoutFileWithSrc)
-                ? path.join(this.projectRoot, 'src', 'components', 'HumanBehaviorProvider.tsx')
-                : path.join(this.projectRoot, 'components', 'HumanBehaviorProvider.tsx');
-            const importPath = fs.existsSync(pagesLayoutFileWithSrc)
-                ? '../components/HumanBehaviorProvider'
-                : './components/HumanBehaviorProvider';
-            // Create dedicated HumanBehavior provider file for Pages Router
-            modifications.push({
-                filePath: providersPath,
-                action: 'create',
-                content: `'use client';
-
-import { HumanBehaviorProvider } from 'humanbehavior-js/react';
-
-export function HBProvider({ children }: { children: React.ReactNode }) {
-  return (
-    <HumanBehaviorProvider apiKey={process.env.NEXT_PUBLIC_HUMANBEHAVIOR_API_KEY}>
-      {children}
-    </HumanBehaviorProvider>
-  );
-}`,
-                description: 'Created HumanBehavior provider file for Pages Router'
-            });
-            // Modify _app.tsx to use the provider
-            const content = fs.readFileSync(actualPagesLayoutFile, 'utf8');
-            const modifiedContent = this.injectNextJSPagesRouter(content, importPath);
-            modifications.push({
-                filePath: actualPagesLayoutFile,
-                action: 'modify',
-                content: modifiedContent,
-                description: 'Added HumanBehavior provider wrapper to Next.js Pages Router'
-            });
-        }
-        // Create or append to environment file
-        modifications.push(this.createEnvironmentModification(this.framework));
-        return modifications;
-    }
-    /**
-     * Generate Astro-specific modifications
-     */
-    async generateAstroModifications() {
-        const modifications = [];
-        // Create Astro component for HumanBehavior
-        const astroComponentPath = path.join(this.projectRoot, 'src', 'components', 'HumanBehavior.astro');
-        const astroComponentContent = `---
-// This component will only run on the client side
----
-
-<script>
-  import { HumanBehaviorTracker } from 'humanbehavior-js';
-  const apiKey = import.meta.env.PUBLIC_HUMANBEHAVIOR_API_KEY;
-  if (apiKey) {
-    HumanBehaviorTracker.init(apiKey);
-  }
-</script>`;
-        modifications.push({
-            filePath: astroComponentPath,
-            action: 'create',
-            content: astroComponentContent,
-            description: 'Created Astro component for HumanBehavior SDK'
+        return JSON.stringify({
+            verified: false,
+            event: VERIFY_EVENT,
+            message: 'Verification event was sent but has not appeared in ClickHouse yet.'
         });
-        // Find and update layout file
-        const layoutFiles = [
-            path.join(this.projectRoot, 'src', 'layouts', 'Layout.astro'),
-            path.join(this.projectRoot, 'src', 'layouts', 'layout.astro'),
-            path.join(this.projectRoot, 'src', 'layouts', 'BaseLayout.astro')
+    }
+    assertSafeCommand(command) {
+        const deniedPatterns = [
+            /\brm\s+-rf\b/,
+            /\bgit\s+reset\b/,
+            /\bgit\s+clean\b/,
+            /\bsudo\b/,
+            /\bchmod\s+-R\b/,
+            />\s*\/dev\/(?:disk|rdisk)/,
         ];
-        let layoutFile = null;
-        for (const file of layoutFiles) {
-            if (fs.existsSync(file)) {
-                layoutFile = file;
-                break;
+        for (const pattern of deniedPatterns) {
+            if (pattern.test(command)) {
+                throw new Error(`Refusing unsafe command: ${command}`);
             }
         }
-        if (layoutFile) {
-            const content = fs.readFileSync(layoutFile, 'utf8');
-            const modifiedContent = this.injectAstroLayout(content);
-            modifications.push({
-                filePath: layoutFile,
-                action: 'modify',
-                content: modifiedContent,
-                description: 'Added HumanBehavior component to Astro layout'
-            });
-        }
-        // Add environment variable
-        modifications.push(this.createEnvironmentModification(this.framework));
-        return modifications;
     }
-    /**
-     * Generate Nuxt-specific modifications
-     */
-    async generateNuxtModifications() {
-        const modifications = [];
-        // Create plugin file for Nuxt (in app directory)
-        const pluginFile = path.join(this.projectRoot, 'app', 'plugins', 'humanbehavior.client.ts');
-        modifications.push({
-            filePath: pluginFile,
-            action: 'create',
-            content: `import { HumanBehaviorTracker } from 'humanbehavior-js';
+}
 
-export default defineNuxtPlugin(() => {
-  const config = useRuntimeConfig();
-  if (typeof window !== 'undefined') {
-    const apiKey = config.public.humanBehaviorApiKey;
-    if (apiKey) {
-      HumanBehaviorTracker.init(apiKey);
+const DEFAULT_APP_URL = 'https://www.humanbehavior.co';
+class ManagedWizardApiClient {
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = (options.baseUrl || process.env.HUMANBEHAVIOR_APP_URL || DEFAULT_APP_URL).replace(/\/$/, '');
     }
-  }
-});`,
-            description: 'Created Nuxt plugin for HumanBehavior SDK in app directory'
+    getRunConsoleUrl(projectSlug, runId) {
+        return `${this.baseUrl}/projects/${projectSlug}/get-started/sdk?wizardRun=${runId}`;
+    }
+    async createRun(input) {
+        const response = await this.request('/api/wizard/runs', {
+            method: 'POST',
+            body: JSON.stringify(input)
         });
-        // Create environment configuration
-        const nuxtConfigFile = path.join(this.projectRoot, 'nuxt.config.ts');
-        {
-            const mod = this.applyOrNotify(nuxtConfigFile, (c) => this.injectNuxtConfig(c), 'Added HumanBehavior runtime config to Nuxt config', 'Nuxt: Add inside defineNuxtConfig({ … }):\nruntimeConfig: { public: { humanBehaviorApiKey: process.env.NUXT_PUBLIC_HUMANBEHAVIOR_API_KEY } },');
-            if (mod)
-                modifications.push(mod);
-        }
-        // Create or append to environment file
-        modifications.push(this.createEnvironmentModification(this.framework));
-        return modifications;
+        return response.json();
     }
-    /**
-     * Generate Remix-specific modifications
-     */
-    async generateRemixModifications() {
-        const modifications = [];
-        // Find root.tsx file
-        const rootFile = path.join(this.projectRoot, 'app', 'root.tsx');
-        if (fs.existsSync(rootFile)) {
-            const content = fs.readFileSync(rootFile, 'utf8');
-            const modifiedContent = this.injectRemixProvider(content);
-            modifications.push({
-                filePath: rootFile,
-                action: 'modify',
-                content: modifiedContent,
-                description: 'Added HumanBehaviorProvider to Remix root component'
-            });
-        }
-        // Create or append to environment file
-        modifications.push(this.createEnvironmentModification(this.framework));
-        return modifications;
+    async updateRun(runId, input) {
+        await this.request(`/api/wizard/runs/${runId}`, {
+            method: 'PATCH',
+            body: JSON.stringify(input)
+        });
     }
-    /**
-     * Generate Vue-specific modifications
-     */
-    async generateVueModifications() {
-        const modifications = [];
-        // Find main.js or main.ts
-        const mainFile = this.findVueMainFile();
-        // Create Vue composable per docs (idempotent)
-        const composableDir = path.join(this.projectRoot, 'src', 'composables');
-        const composablePath = path.join(composableDir, 'useHumanBehavior.ts');
-        const composableContent = `import { HumanBehaviorTracker } from 'humanbehavior-js'
-
-export function useHumanBehavior() {
-  const apiKey = import.meta.env.VITE_HUMANBEHAVIOR_API_KEY
-  
-  if (apiKey) {
-    const tracker = HumanBehaviorTracker.init(apiKey);
-    
-    return { tracker }
-  }
-  
-  return { tracker: null }
-}
-`;
-        try {
-            if (!fs.existsSync(composableDir)) {
-                fs.mkdirSync(composableDir, { recursive: true });
-            }
-            if (!fs.existsSync(composablePath)) {
-                modifications.push({
-                    filePath: composablePath,
-                    action: 'create',
-                    content: composableContent,
-                    description: 'Created Vue composable useHumanBehavior'
-                });
+    async createAgentSession(input) {
+        const response = await this.request('/api/wizard/agent-sessions', {
+            method: 'POST',
+            body: JSON.stringify(input)
+        });
+        return response.json();
+    }
+    async runAgentTurn(sessionId, sessionToken, messages) {
+        const response = await this.request(`/api/wizard/agent-sessions/${sessionId}/turn`, {
+            method: 'POST',
+            body: JSON.stringify({ messages })
+        }, sessionToken);
+        return response.json();
+    }
+    async verifyRun(runId) {
+        const response = await this.request(`/api/wizard/runs/${runId}/verify`, {
+            method: 'POST',
+            body: JSON.stringify({})
+        });
+        return response.json();
+    }
+    async request(path, init, token = this.apiKey) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            ...init,
+            headers: {
+                'content-type': 'application/json',
+                authorization: `Bearer ${token}`,
+                ...init.headers
             }
+        });
+        if (!response.ok) {
+            const message = await response.text().catch(() => response.statusText);
+            throw new Error(`Wizard API request failed (${response.status}): ${message || response.statusText}`);
         }
-        catch { }
-        if (mainFile) {
-            const content = fs.readFileSync(mainFile, 'utf8');
-            const modifiedContent = this.injectVuePlugin(content);
-            modifications.push({
-                filePath: mainFile,
-                action: 'modify',
-                content: modifiedContent,
-                description: 'Added HumanBehaviorPlugin to Vue app'
-            });
-        }
-        // Create or append to environment file
-        modifications.push(this.createEnvironmentModification(this.framework));
-        return modifications;
+        return response;
     }
-    /**
-     * Generate Angular-specific modifications
-     */
-    async generateAngularModifications() {
-        const modifications = [];
-        // Create Angular service (docs pattern)
-        const serviceDir = path.join(this.projectRoot, 'src', 'app', 'services');
-        const servicePath = path.join(serviceDir, 'hb.service.ts');
-        const serviceContent = `import { Injectable, NgZone, Inject, PLATFORM_ID } from '@angular/core';
-import { isPlatformBrowser } from '@angular/common';
-import { HumanBehaviorTracker } from 'humanbehavior-js';
-import { environment } from '../../environments/environment';
-
-@Injectable({ providedIn: 'root' })
-export class HumanBehavior {
-  private tracker: ReturnType<typeof HumanBehaviorTracker.init> | null = null;
+}
 
-  constructor(private ngZone: NgZone, @Inject(PLATFORM_ID) private platformId: Object) {
-    if (isPlatformBrowser(this.platformId)) {
-      this.ngZone.runOutsideAngular(() => {
-        this.tracker = HumanBehaviorTracker.init(environment.humanBehaviorApiKey);
-      });
+const MANUAL_DOCS_URL = 'https://documentation.humanbehavior.co';
+const MAX_AGENT_TURNS = 18;
+class AgentInstallationRunner {
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.projectPath = path.resolve(options.projectPath || process.cwd());
+        this.executionMode = options.executionMode || 'interactive';
+        this.ingestionUrl = options.ingestionUrl;
+        this.apiClient = new ManagedWizardApiClient({
+            apiKey: options.apiKey,
+            baseUrl: options.appUrl
+        });
     }
-  }
-
-  capture(event: string, props?: Record<string, any>) {
-    this.tracker?.customEvent(event, props);
-  }
-
-  identify(user: Record<string, any>) {
-    this.tracker?.identifyUser({ userProperties: user });
-  }
-
-  trackPageView(path?: string) {
-    this.tracker?.trackPageView(path);
-  }
-}
-`;
-        if (!fs.existsSync(serviceDir)) {
-            fs.mkdirSync(serviceDir, { recursive: true });
+    async run() {
+        const repo = this.scanRepo();
+        let runId = null;
+        let dashboardUrl;
+        let syncWarning = null;
+        let agentSession = null;
+        if (!this.apiKey.startsWith('hb_')) {
+            return this.failure(repo, 'HumanBehavior API key should start with "hb_".');
         }
-        if (!fs.existsSync(servicePath)) {
-            modifications.push({
-                filePath: servicePath,
-                action: 'create',
-                content: serviceContent,
-                description: 'Created Angular HumanBehavior service (singleton)'
+        try {
+            const created = await this.apiClient.createRun({
+                executionMode: this.executionMode,
+                repo
             });
+            runId = created.run.id;
+            dashboardUrl = this.apiClient.getRunConsoleUrl(created.projectSlug, created.run.id);
         }
-        // Handle Angular environment files (proper Angular way)
-        const envFile = path.join(this.projectRoot, 'src', 'environments', 'environment.ts');
-        const envProdFile = path.join(this.projectRoot, 'src', 'environments', 'environment.prod.ts');
-        // Create environments directory if it doesn't exist
-        const envDir = path.dirname(envFile);
-        if (!fs.existsSync(envDir)) {
-            fs.mkdirSync(envDir, { recursive: true });
-        }
-        // Create or update development environment
-        if (fs.existsSync(envFile)) {
-            const content = fs.readFileSync(envFile, 'utf8');
-            if (!content.includes('humanBehaviorApiKey')) {
-                const modifiedContent = content.replace(/export const environment = {([\s\S]*?)};/, `export const environment = {
-  $1,
-  humanBehaviorApiKey: '${this.apiKey}'
-};`);
-                modifications.push({
-                    filePath: envFile,
-                    action: 'modify',
-                    content: modifiedContent,
-                    description: 'Added API key to Angular development environment'
-                });
+        catch (error) {
+            if (this.executionMode === 'dry-run') {
+                syncWarning = `Dashboard sync unavailable: ${error instanceof Error ? error.message : 'Unknown error'}`;
             }
-        }
-        else {
-            // Create new development environment file
-            modifications.push({
-                filePath: envFile,
-                action: 'create',
-                content: `export const environment = {
-  production: false,
-  humanBehaviorApiKey: '${this.apiKey}'
-};`,
-                description: 'Created Angular development environment file'
-            });
-        }
-        // Create or update production environment
-        if (fs.existsSync(envProdFile)) {
-            const content = fs.readFileSync(envProdFile, 'utf8');
-            if (!content.includes('humanBehaviorApiKey')) {
-                const modifiedContent = content.replace(/export const environment = {([\s\S]*?)};/, `export const environment = {
-  $1,
-  humanBehaviorApiKey: '${this.apiKey}'
-};`);
-                modifications.push({
-                    filePath: envProdFile,
-                    action: 'modify',
-                    content: modifiedContent,
-                    description: 'Added API key to Angular production environment'
-                });
+            else {
+                return this.failure(repo, `Could not start a managed wizard run: ${error instanceof Error ? error.message : 'Unknown error'}`);
             }
         }
-        else {
-            // Create new production environment file
-            modifications.push({
-                filePath: envProdFile,
-                action: 'create',
-                content: `export const environment = {
-  production: true,
-  humanBehaviorApiKey: '${this.apiKey}'
-};`,
-                description: 'Created Angular production environment file'
+        if (this.executionMode === 'dry-run') {
+            const result = {
+                success: true,
+                phase: 'analyze',
+                repo,
+                errors: [],
+                nextSteps: [
+                    'Dry run complete. No files were changed.',
+                    'The managed agent session is required before edit planning can run.',
+                    ...(dashboardUrl ? [`Dashboard run: ${dashboardUrl}`] : []),
+                    ...(syncWarning ? [syncWarning] : []),
+                    `Manual setup docs: ${MANUAL_DOCS_URL}`
+                ],
+                dashboardUrl
+            };
+            await this.updateRunSafely(runId, {
+                status: 'completed',
+                phase: 'finish',
+                result
             });
+            return result;
         }
-        // For Angular, we don't need .env files since we use environment.ts
-        // The environment files are already created above
-        // Inject service into app component
-        const appComponentPath = path.join(this.projectRoot, 'src', 'app', 'app.ts');
-        if (fs.existsSync(appComponentPath)) {
-            const appContent = fs.readFileSync(appComponentPath, 'utf8');
-            // Check if already has HumanBehavior service
-            if (!appContent.includes('HumanBehavior')) {
-                let modifiedAppContent = appContent
-                    .replace(/import { Component } from '@angular\/core';/, `import { Component } from '@angular/core';
-import { HumanBehavior } from './services/hb.service';`)
-                    .replace(/export class App {/, `export class App {
-  constructor(private readonly humanBehavior: HumanBehavior) {}`);
-                // Do not modify standalone setting; leave component decorator unchanged
-                modifications.push({
-                    action: 'modify',
-                    filePath: appComponentPath,
-                    content: modifiedAppContent,
-                    description: 'Injected HumanBehavior service into Angular app component'
-                });
-            }
-        }
-        return modifications;
-    }
-    /**
-     * Generate Svelte-specific modifications
-     */
-    async generateSvelteModifications() {
-        const modifications = [];
-        // Check for SvelteKit
-        const svelteConfigFile = path.join(this.projectRoot, 'svelte.config.js');
-        const isSvelteKit = fs.existsSync(svelteConfigFile);
-        if (isSvelteKit) {
-            // SvelteKit - create layout file
-            const layoutFile = path.join(this.projectRoot, 'src', 'routes', '+layout.svelte');
-            if (fs.existsSync(layoutFile)) {
-                const content = fs.readFileSync(layoutFile, 'utf8');
-                const modifiedContent = this.injectSvelteKitLayout(content);
-                modifications.push({
-                    filePath: layoutFile,
-                    action: 'modify',
-                    content: modifiedContent,
-                    description: 'Added HumanBehavior tracker init to SvelteKit layout'
-                });
-            }
-        }
-        else {
-            // Regular Svelte - modify main file
-            const mainFile = this.findSvelteMainFile();
-            if (mainFile) {
-                const content = fs.readFileSync(mainFile, 'utf8');
-                const modifiedContent = this.injectSvelteStore(content);
-                modifications.push({
-                    filePath: mainFile,
-                    action: 'modify',
-                    content: modifiedContent,
-                    description: 'Added HumanBehavior tracker init to Svelte app'
-                });
+        try {
+            if (!runId) {
+                throw new Error('Wizard run was not created.');
             }
-        }
-        // Create or append to environment file
-        modifications.push(this.createEnvironmentModification(this.framework));
-        return modifications;
-    }
-    /**
-     * Generate vanilla JS/TS modifications
-     */
-    async generateVanillaModifications() {
-        const modifications = [];
-        // Find HTML file to inject script
-        const htmlFile = this.findHTMLFile();
-        if (htmlFile) {
-            const content = fs.readFileSync(htmlFile, 'utf8');
-            const modifiedContent = this.injectVanillaScript(content);
-            modifications.push({
-                filePath: htmlFile,
-                action: 'modify',
-                content: modifiedContent,
-                description: 'Added HumanBehavior CDN script to HTML file'
-            });
-        }
-        // Create or append to environment file
-        modifications.push(this.createEnvironmentModification(this.framework));
-        return modifications;
-    }
-    /**
-     * Generate Gatsby-specific modifications
-     */
-    async generateGatsbyModifications() {
-        const modifications = [];
-        // Modify or create gatsby-browser.js for Gatsby
-        const gatsbyBrowserFile = path.join(this.projectRoot, 'gatsby-browser.js');
-        if (fs.existsSync(gatsbyBrowserFile)) {
-            const content = fs.readFileSync(gatsbyBrowserFile, 'utf8');
-            const modifiedContent = this.injectGatsbyBrowser(content);
-            modifications.push({
-                filePath: gatsbyBrowserFile,
-                action: 'modify',
-                content: modifiedContent,
-                description: 'Added HumanBehavior initialization to Gatsby browser'
+            const session = await this.apiClient.createAgentSession({
+                runId,
+                permissionMode: this.executionMode === 'yes' ? 'acceptEdits' : 'default'
             });
-        }
-        else {
-            // Create gatsby-browser.js if it doesn't exist
-            modifications.push({
-                filePath: gatsbyBrowserFile,
-                action: 'create',
-                content: `import { HumanBehaviorTracker } from 'humanbehavior-js';
-
-export const onClientEntry = () => {
-  const apiKey = process.env.GATSBY_HUMANBEHAVIOR_API_KEY;
-  if (apiKey) {
-    HumanBehaviorTracker.init(apiKey);
-  }
-};`,
-                description: 'Created gatsby-browser.js with HumanBehavior initialization'
-            });
-        }
-        // Create or append to environment file
-        modifications.push(this.createEnvironmentModification(this.framework));
-        return modifications;
-    }
-    /**
-     * Apply modifications to the codebase
-     */
-    async applyModifications(modifications) {
-        for (const modification of modifications) {
-            try {
-                const dir = path.dirname(modification.filePath);
-                if (!fs.existsSync(dir)) {
-                    fs.mkdirSync(dir, { recursive: true });
-                }
-                switch (modification.action) {
-                    case 'create':
-                        fs.writeFileSync(modification.filePath, modification.content);
-                        break;
-                    case 'modify':
-                        fs.writeFileSync(modification.filePath, modification.content);
-                        break;
-                    case 'append':
-                        fs.appendFileSync(modification.filePath, '\n' + modification.content);
-                        break;
-                }
-            }
-            catch (error) {
-                throw new Error(`Failed to apply modification to ${modification.filePath}: ${error}`);
-            }
-        }
-    }
-    /**
-     * Generate next steps for the user
-     */
-    generateNextSteps() {
-        const steps = [
-            '✅ SDK installed and configured automatically!',
-            '🚀 Your app is now tracking user behavior',
-            '📊 View sessions in your HumanBehavior dashboard',
-            '🔧 Customize tracking in your code as needed'
-        ];
-        if (this.framework?.type === 'react' || this.framework?.type === 'nextjs') {
-            steps.push('💡 Use the useHumanBehavior() hook to track custom events');
-        }
-        // Append any manual notes gathered during transformation
-        if (this.manualNotes.length) {
-            steps.push(...this.manualNotes.map((n) => `⚠️ ${n}`));
-        }
-        return steps;
-    }
-    /**
-     * Helper: apply a file transform or record a manual instruction if unchanged/missing
-     */
-    applyOrNotify(filePath, transform, description, manualNote) {
-        if (!fs.existsSync(filePath)) {
-            this.manualNotes.push(`${manualNote} (file missing: ${path.relative(this.projectRoot, filePath)})`);
-            return null;
-        }
-        const original = fs.readFileSync(filePath, 'utf8');
-        const updated = transform(original);
-        if (updated !== original) {
-            return {
-                filePath,
-                action: 'modify',
-                content: updated,
-                description
+            agentSession = {
+                id: session.session.id,
+                token: session.sessionToken
             };
         }
-        this.manualNotes.push(manualNote);
-        return null;
-    }
-    // Helper methods for file detection and content injection
-    findReactAppFile() {
-        const possibleFiles = [
-            'src/App.jsx', 'src/App.js', 'src/App.tsx', 'src/App.ts',
-            'src/index.js', 'src/index.tsx', 'src/main.js', 'src/main.tsx'
-        ];
-        for (const file of possibleFiles) {
-            const fullPath = path.join(this.projectRoot, file);
-            if (fs.existsSync(fullPath)) {
-                return fullPath;
+        catch (error) {
+            const result = this.failure(repo, `Could not start managed Claude agent session: ${error instanceof Error ? error.message : 'Unknown error'}`, dashboardUrl);
+            await this.updateRunSafely(runId, {
+                status: 'failed',
+                phase: 'analyze',
+                result
+            });
+            return result;
+        }
+        return this.runRemoteToolLoop(runId, agentSession, repo, dashboardUrl);
+    }
+    async runRemoteToolLoop(runId, session, repo, dashboardUrl) {
+        let installationVerified = false;
+        const executor = new LocalToolExecutor(this.projectPath, {
+            apiKey: this.apiKey,
+            runId,
+            ingestionUrl: this.ingestionUrl,
+            verifyRun: async () => {
+                const verification = await this.apiClient.verifyRun(runId);
+                if (verification.verified)
+                    installationVerified = true;
+                return verification;
             }
-        }
-        return null;
-    }
-    findVueMainFile() {
-        const possibleFiles = [
-            'src/main.js', 'src/main.ts', 'src/main.jsx', 'src/main.tsx'
-        ];
-        for (const file of possibleFiles) {
-            const fullPath = path.join(this.projectRoot, file);
-            if (fs.existsSync(fullPath)) {
-                return fullPath;
+        });
+        const messages = [
+            {
+                role: 'user',
+                content: this.createInitialPrompt(repo)
             }
-        }
-        return null;
-    }
-    findSvelteMainFile() {
-        const possibleFiles = [
-            'src/main.js', 'src/main.ts', 'src/main.svelte'
         ];
-        for (const file of possibleFiles) {
-            const fullPath = path.join(this.projectRoot, file);
-            if (fs.existsSync(fullPath)) {
-                return fullPath;
-            }
-        }
-        return null;
-    }
-    findHTMLFile() {
-        const possibleFiles = ['index.html', 'public/index.html', 'dist/index.html'];
-        for (const file of possibleFiles) {
-            const fullPath = path.join(this.projectRoot, file);
-            if (fs.existsSync(fullPath)) {
-                return fullPath;
-            }
-        }
-        return null;
-    }
-    injectReactProvider(content, filePath) {
-        filePath.endsWith('.tsx') || filePath.endsWith('.ts');
-        // Check if already has HumanBehaviorProvider
-        if (content.includes('HumanBehaviorProvider')) {
-            return content;
-        }
-        // Determine the correct environment variable syntax based on bundler
-        const isVite = this.framework?.bundler === 'vite';
-        const envVar = isVite
-            ? 'import.meta.env.VITE_HUMANBEHAVIOR_API_KEY!'
-            : 'process.env.REACT_APP_HUMANBEHAVIOR_API_KEY!';
-        const importStatement = `import { HumanBehaviorProvider } from 'humanbehavior-js/react';`;
-        // Enhanced parsing for React 18+ features
-        const hasReact18 = this.framework?.features?.hasReact18;
-        // Handle different React patterns
-        if (content.includes('function App()') || content.includes('const App =')) {
-            // Add import statement
-            let modifiedContent = content.replace(/(import.*?from.*?['"]react['"];?)/, `$1\n${importStatement}`);
-            // If no React import found, add it at the top
-            if (!modifiedContent.includes(importStatement)) {
-                modifiedContent = `${importStatement}\n\n${modifiedContent}`;
-            }
-            // Wrap the App component return with HumanBehaviorProvider
-            modifiedContent = modifiedContent.replace(/return\s*\(([\s\S]*?)\)\s*;/, `return (
-    <HumanBehaviorProvider apiKey={${envVar}}>
-      $1
-    </HumanBehaviorProvider>
-  );`);
-            return modifiedContent;
-        }
-        // Handle React 18+ createRoot pattern
-        if (hasReact18 && content.includes('createRoot')) {
-            let modifiedContent = content.replace(/(import.*?from.*?['"]react['"];?)/, `$1\n${importStatement}`);
-            if (!modifiedContent.includes(importStatement)) {
-                modifiedContent = `${importStatement}\n\n${modifiedContent}`;
-            }
-            // Wrap the root render with HumanBehaviorProvider
-            modifiedContent = modifiedContent.replace(/(root\.render\s*\([\s\S]*?\)\s*;)/, `root.render(
-    <HumanBehaviorProvider apiKey={${envVar}}>
-      $1
-    </HumanBehaviorProvider>
-  );`);
-            return modifiedContent;
-        }
-        // Fallback: simple injection
-        return `${importStatement}\n\n${content}`;
-    }
-    injectNextJSAppRouter(content, importPath = '@/app/providers') {
-        if (content.includes('HBProvider')) {
-            return content;
-        }
-        const importStatement = `import { HBProvider } from '${importPath}';`;
-        // First, add the import statement
-        let modifiedContent = content.replace(/export default function RootLayout/, `${importStatement}\n\nexport default function RootLayout`);
-        // Then wrap the body content with Providers
-        // Use a more specific approach to handle the body content
-        modifiedContent = modifiedContent.replace(/<body([^>]*)>([\s\S]*?)<\/body>/, (match, bodyAttrs, bodyContent) => {
-            // Trim whitespace and newlines from bodyContent
-            const trimmedContent = bodyContent.trim();
-            return `<body${bodyAttrs}>
-        <HBProvider>
-          ${trimmedContent}
-        </HBProvider>
-      </body>`;
-        });
-        return modifiedContent;
-    }
-    injectNextJSPagesRouter(content, importPath = '../components/HumanBehaviorProvider') {
-        if (content.includes('HBProvider')) {
-            return content;
-        }
-        const importStatement = `import { HBProvider } from '${importPath}';`;
-        return content.replace(/function MyApp/, `${importStatement}\n\nfunction MyApp`).replace(/return \(([\s\S]*?)\);/, `return (
-    <HBProvider>
-      $1
-    </HBProvider>
-  );`);
-    }
-    injectRemixProvider(content) {
-        if (content.includes('HumanBehaviorProvider')) {
-            return content;
-        }
-        let modifiedContent = content;
-        // Step 1: Add useLoaderData import
-        if (!content.includes('useLoaderData')) {
-            modifiedContent = modifiedContent.replace(/(} from ['"]@remix-run\/react['"];?\s*)/, `$1import { useLoaderData } from '@remix-run/react';
-`);
-        }
-        // Step 2: Add HumanBehaviorProvider import
-        if (!content.includes('HumanBehaviorProvider')) {
-            modifiedContent = modifiedContent.replace(/(} from ['"]@remix-run\/react['"];?\s*)/, `$1import { HumanBehaviorProvider } from 'humanbehavior-js/react';
-`);
-        }
-        // Step 3: Add LoaderFunctionArgs import
-        if (!content.includes('LoaderFunctionArgs')) {
-            modifiedContent = modifiedContent.replace(/(} from ['"]@remix-run\/node['"];?\s*)/, `$1import type { LoaderFunctionArgs } from '@remix-run/node';
-`);
-        }
-        // Step 4: Add loader function before Layout function
-        if (!content.includes('export const loader')) {
-            modifiedContent = modifiedContent.replace(/(export function Layout)/, `export const loader = async ({ request }: LoaderFunctionArgs) => {
-  return {
-    ENV: {
-      HUMANBEHAVIOR_API_KEY: process.env.HUMANBEHAVIOR_API_KEY,
-    },
-  };
-};
-
-$1`);
-        }
-        // Step 5: Add useLoaderData call and wrap App function's return content with HumanBehaviorProvider
-        if (!content.includes('const data = useLoaderData')) {
-            modifiedContent = modifiedContent.replace(/(export default function App\(\) \{\s*)(return \(\s*<div[^>]*>[\s\S]*?<\/div>\s*\);\s*\})/, `$1const data = useLoaderData<typeof loader>();
-  
-  return (
-    <HumanBehaviorProvider apiKey={data.ENV.HUMANBEHAVIOR_API_KEY}>
-      <div className="min-h-screen bg-gray-50">
-        <Navigation />
-        <Outlet />
-      </div>
-    </HumanBehaviorProvider>
-  );
-}`);
-        }
-        return modifiedContent;
-    }
-    injectVuePlugin(content) {
-        // New: use composable/tracker pattern per docs; idempotent and migrates from plugin
-        if (content.includes('useHumanBehavior')) {
-            return content;
-        }
-        const hasVue3 = this.framework?.features?.hasVue3;
-        const isVue3ByContent = content.includes('createApp') || content.includes('import { createApp }');
-        let modifiedContent = content
-            .replace(/import\s*\{\s*HumanBehaviorPlugin\s*\}\s*from\s*['\"]humanbehavior-js\/vue['\"];?/g, '')
-            .replace(/app\.use\(\s*HumanBehaviorPlugin[\s\S]*?\);?/g, '');
-        if (hasVue3 || isVue3ByContent) {
-            const importComposable = `import { useHumanBehavior } from './composables/useHumanBehavior';`;
-            if (!modifiedContent.includes(importComposable)) {
-                const lastImportIndex = modifiedContent.lastIndexOf('import');
-                if (lastImportIndex !== -1) {
-                    const nextLineIndex = modifiedContent.indexOf('\n', lastImportIndex);
-                    if (nextLineIndex !== -1) {
-                        modifiedContent = modifiedContent.slice(0, nextLineIndex + 1) + importComposable + '\n' + modifiedContent.slice(nextLineIndex + 1);
-                    }
-                    else {
-                        modifiedContent = modifiedContent + '\n' + importComposable;
-                    }
-                }
-                else {
-                    modifiedContent = importComposable + '\n' + modifiedContent;
+        for (let turn = 0; turn < MAX_AGENT_TURNS; turn++) {
+            const response = await this.apiClient.runAgentTurn(session.id, session.token, messages);
+            messages.push({
+                role: 'assistant',
+                content: response.message.content
+            });
+            if (response.toolRequests.length === 0) {
+                if (!installationVerified) {
+                    const result = this.failure(repo, 'Managed agent stopped before verification completed.', dashboardUrl);
+                    await this.updateRunSafely(runId, {
+                        status: 'failed',
+                        phase: 'check-errors',
+                        result
+                    });
+                    return result;
                 }
-            }
-            if (modifiedContent.includes('createApp')) {
-                modifiedContent = modifiedContent.replace(/(const\s+app\s*=\s*createApp\([^)]*\))/, `$1\nconst { tracker } = useHumanBehavior();`);
-            }
-            return modifiedContent;
-        }
-        else {
-            const trackerImport = `import { HumanBehaviorTracker } from 'humanbehavior-js';`;
-            if (!modifiedContent.includes(trackerImport)) {
-                modifiedContent = `${trackerImport}\n${modifiedContent}`;
-            }
-            if (modifiedContent.includes('new Vue')) {
-                modifiedContent = modifiedContent.replace(/(new\s+Vue\s*\()/, `HumanBehaviorTracker.init(process.env.VUE_APP_HUMANBEHAVIOR_API_KEY || import.meta?.env?.VITE_HUMANBEHAVIOR_API_KEY);\n$1`);
-            }
-            return modifiedContent;
-        }
-    }
-    injectAngularModule(content) {
-        if (content.includes('HumanBehaviorModule')) {
-            return content;
-        }
-        const importStatement = `import { HumanBehaviorModule } from 'humanbehavior-js/angular';`;
-        const environmentImport = `import { environment } from '../environments/environment';`;
-        // Add environment import if not present
-        let modifiedContent = content;
-        if (!content.includes('environment')) {
-            modifiedContent = content.replace(/import.*from.*['"]@angular/, `${environmentImport}\n$&`);
-        }
-        return modifiedContent.replace(/imports:\s*\[([\s\S]*?)\]/, `imports: [
-    $1,
-    HumanBehaviorModule.forRoot({
-      apiKey: environment.humanBehaviorApiKey
-    })
-  ]`).replace(/import.*from.*['"]@angular/, `$&\n${importStatement}`);
-    }
-    injectAngularStandaloneInit(content) {
-        if (content.includes('initializeHumanBehavior')) {
-            return content;
-        }
-        const importStatement = `import { initializeHumanBehavior } from 'humanbehavior-js/angular';`;
-        const environmentImport = `import { environment } from './environments/environment';`;
-        // Add imports at the top
-        let modifiedContent = content.replace(/import.*from.*['"]@angular/, `${importStatement}\n${environmentImport}\n$&`);
-        // Add initialization after bootstrapApplication
-        modifiedContent = modifiedContent.replace(/(bootstrapApplication\([^}]+\}?\)(?:\s*\.catch[^;]+;)?)/, `$1
-
-// Initialize HumanBehavior SDK (client-side only)
-if (typeof window !== 'undefined') {
-  const tracker = initializeHumanBehavior(environment.humanBehaviorApiKey);
-}`);
-        return modifiedContent;
-    }
-    injectSvelteStore(content) {
-        // Direct tracker init for non-SSR Svelte
-        if (content.includes('HumanBehaviorTracker.init')) {
-            return content;
-        }
-        const importStatement = `import { HumanBehaviorTracker } from 'humanbehavior-js';`;
-        const initCode = `// Initialize HumanBehavior SDK\nHumanBehaviorTracker.init(import.meta.env?.VITE_HUMANBEHAVIOR_API_KEY || process.env.PUBLIC_HUMANBEHAVIOR_API_KEY || '');`;
-        return `${importStatement}\n${initCode}\n\n${content}`;
-    }
-    injectSvelteKitLayout(content) {
-        // Direct tracker init with browser guard for SvelteKit
-        if (content.includes('HumanBehaviorTracker.init')) {
-            return content;
-        }
-        const envImport = `import { PUBLIC_HUMANBEHAVIOR_API_KEY } from '$env/static/public';`;
-        const hbImport = `import { HumanBehaviorTracker } from 'humanbehavior-js';`;
-        const browserImport = `import { browser } from '$app/environment';`;
-        const initCode = `if (browser) {\n  const apiKey = PUBLIC_HUMANBEHAVIOR_API_KEY || import.meta.env.VITE_HUMANBEHAVIOR_API_KEY;\n  if (apiKey) {\n    HumanBehaviorTracker.init(apiKey);\n  }\n}`;
-        if (content.includes('<script lang="ts">')) {
-            return content.replace(/<script lang="ts">/, `<script lang="ts">\n\t${browserImport}\n\t${envImport}\n\t${hbImport}\n\t${initCode}`);
-        }
-        else if (content.includes('<script>')) {
-            return content.replace(/<script>/, `<script>\n\t${browserImport}\n\t${envImport}\n\t${hbImport}\n\t${initCode}`);
-        }
-        else {
-            return `<script lang="ts">\n${browserImport}\n${envImport}\n${hbImport}\n${initCode}\n</script>\n\n${content}`;
-        }
-    }
-    injectVanillaScript(content) {
-        if (content.includes('humanbehavior-js')) {
-            return content;
-        }
-        const cdnScript = `<script src="https://unpkg.com/humanbehavior-js@latest/dist/index.min.js"></script>`;
-        const initScript = `<script>
-  // Initialize HumanBehavior SDK
-  // Note: For vanilla HTML, the API key must be hardcoded since env vars aren't available
-  const tracker = HumanBehaviorTracker.init('${this.apiKey}');
-</script>`;
-        return content.replace(/<\/head>/, `  ${cdnScript}\n  ${initScript}\n</head>`);
-    }
-    /**
-     * Inject Astro layout with HumanBehavior component
-     */
-    injectAstroLayout(content) {
-        // Check if HumanBehavior component is already imported
-        if (content.includes('HumanBehavior') || content.includes('humanbehavior-js')) {
-            return content; // Already has HumanBehavior
-        }
-        // Add import inside frontmatter if not present
-        let modifiedContent = content;
-        if (!content.includes('import HumanBehavior')) {
-            const importStatement = 'import HumanBehavior from \'../components/HumanBehavior.astro\';';
-            const frontmatterEndIndex = content.indexOf('---', 3);
-            if (frontmatterEndIndex !== -1) {
-                // Insert import inside frontmatter, before the closing ---
-                modifiedContent = content.slice(0, frontmatterEndIndex) + '\n' + importStatement + '\n' + content.slice(frontmatterEndIndex);
-            }
-            else {
-                // No frontmatter, add at the very beginning
-                modifiedContent = '---\n' + importStatement + '\n---\n\n' + content;
-            }
-        }
-        // Find the closing </body> tag and add HumanBehavior component before it
-        const bodyCloseIndex = modifiedContent.lastIndexOf('</body>');
-        if (bodyCloseIndex === -1) {
-            // No body tag found, append to end
-            return modifiedContent + '\n\n<HumanBehavior />';
-        }
-        // Add component before closing body tag
-        return modifiedContent.slice(0, bodyCloseIndex) + '  <HumanBehavior />\n' + modifiedContent.slice(bodyCloseIndex);
-    }
-    injectNuxtConfig(content) {
-        if (content.includes('humanBehaviorApiKey')) {
-            return content;
-        }
-        // Enhanced Nuxt 3 support with version detection
-        const hasNuxt3 = this.framework?.features?.hasNuxt3;
-        if (hasNuxt3) {
-            // Nuxt 3 with runtime config (robust match for opening object)
-            const pattern = /export\s+default\s+defineNuxtConfig\s*\(\s*\{/;
-            if (pattern.test(content)) {
-                const replaced = content.replace(pattern, `export default defineNuxtConfig({\n  runtimeConfig: {\n    public: {\n      humanBehaviorApiKey: process.env.NUXT_PUBLIC_HUMANBEHAVIOR_API_KEY\n    }\n  },`);
-                if (replaced !== content)
-                    return replaced;
-            }
-            // Fallback: insert runtimeConfig after opening brace of defineNuxtConfig
-            const startIdx = content.indexOf('defineNuxtConfig(');
-            if (startIdx !== -1) {
-                const braceIdx = content.indexOf('{', startIdx);
-                if (braceIdx !== -1) {
-                    const insertion = `\n  runtimeConfig: {\n    public: {\n      humanBehaviorApiKey: process.env.NUXT_PUBLIC_HUMANBEHAVIOR_API_KEY\n    }\n  },`;
-                    const before = content.slice(0, braceIdx + 1);
-                    const after = content.slice(braceIdx + 1);
-                    return `${before}${insertion}${after}`;
+                const result = {
+                    success: true,
+                    phase: 'finish',
+                    repo,
+                    errors: [],
+                    nextSteps: [
+                        'Managed agent loop completed.',
+                        'Review the local git diff before committing.',
+                        ...(dashboardUrl ? [`Dashboard run: ${dashboardUrl}`] : [])
+                    ],
+                    dashboardUrl
+                };
+                await this.updateRunSafely(runId, {
+                    status: 'completed',
+                    phase: 'finish',
+                    result
+                });
+                return result;
+            }
+            await this.updateRunSafely(runId, {
+                status: 'running',
+                phase: this.phaseForTools(response.toolRequests),
+                result: {
+                    success: false,
+                    nextSteps: [`Executing ${response.toolRequests.length} agent tool request(s).`]
                 }
+            });
+            const toolResults = [];
+            for (const toolRequest of response.toolRequests) {
+                toolResults.push(await executor.execute(toolRequest));
             }
-            return content;
-        }
-        else {
-            // Nuxt 2 with env config
-            return content.replace(/export default \{/, `export default {
-  env: {
-    humanBehaviorApiKey: process.env.HUMANBEHAVIOR_API_KEY
-  },`);
+            messages.push({
+                role: 'user',
+                content: toolResults
+            });
         }
+        const result = this.failure(repo, `Managed agent exceeded ${MAX_AGENT_TURNS} turns before finishing.`, dashboardUrl);
+        await this.updateRunSafely(runId, {
+            status: 'failed',
+            phase: 'check-errors',
+            result
+        });
+        return result;
     }
-    injectGatsbyLayout(content) {
-        if (content.includes('HumanBehavior')) {
-            return content;
+    createInitialPrompt(repo) {
+        return [
+            'Run the Human Behavior SDK installation now.',
+            '',
+            `Project root: ${this.projectPath}`,
+            `Execution mode: ${this.executionMode}`,
+            `Human Behavior API key: ${this.apiKey}`,
+            `Package manager: ${repo.packageManager}`,
+            `Workspace shape: ${repo.workspaceShape}`,
+            `package.json files: ${repo.packageJsonPaths.join(', ') || 'none'}`,
+            '',
+            'Use the available tools to inspect and edit the project.',
+            'Do not inspect node_modules, package-lock.json, pnpm-lock.yaml, yarn.lock, build output, or dist output unless absolutely necessary.',
+            'For browser SDK imports, humanbehavior-js has no default export. Use named exports, for example: import { init } from "humanbehavior-js"; then call init(apiKey).',
+            'When using hb_write_file, write exactly one complete file body. Do not duplicate previous file contents.',
+            'When finished, stop requesting tools and summarize what changed.'
+        ].join('\n');
+    }
+    phaseForTools(toolRequests) {
+        if (toolRequests.some((tool) => tool.name === 'hb_verify_installation')) {
+            return 'check-errors';
+        }
+        if (toolRequests.some((tool) => tool.name === 'hb_write_file')) {
+            return 'edit';
+        }
+        if (toolRequests.some((tool) => tool.name === 'hb_bash')) {
+            return 'check-errors';
+        }
+        return 'analyze';
+    }
+    async updateRunSafely(runId, input) {
+        if (!runId)
+            return;
+        try {
+            await this.apiClient.updateRun(runId, input);
         }
-        const importStatement = `import HumanBehavior from './HumanBehavior';`;
-        const componentUsage = `<HumanBehavior apiKey={process.env.GATSBY_HUMANBEHAVIOR_API_KEY || ''} />`;
-        // Add import at the top
-        let modifiedContent = content.replace(/import.*from.*['"]\./, `${importStatement}\n$&`);
-        // Add component before closing body tag
-        modifiedContent = modifiedContent.replace(/(\s*<\/body>)/, `\n      ${componentUsage}\n$1`);
-        return modifiedContent;
-    }
-    injectGatsbyBrowser(content) {
-        const importStatement = `import { HumanBehaviorTracker } from 'humanbehavior-js';`;
-        // If an onClientEntry already exists, merge init into it idempotently
-        if (/export\s+const\s+onClientEntry\s*=\s*\(/.test(content)) {
-            let modified = content;
-            // Ensure import exists
-            if (!modified.includes("from 'humanbehavior-js'")) {
-                modified = `${importStatement}\n${modified}`;
-            }
-            // If init already present, return as-is
-            if (modified.includes('HumanBehaviorTracker.init(')) {
-                return modified;
-            }
-            // Inject minimal init at start of onClientEntry body
-            modified = modified.replace(/(export\s+const\s+onClientEntry\s*=\s*\([^)]*\)\s*=>\s*\{)/, `$1\n  const apiKey = process.env.GATSBY_HUMANBEHAVIOR_API_KEY;\n  if (apiKey) {\n    HumanBehaviorTracker.init(apiKey);\n  }\n`);
-            return modified;
+        catch {
+            // The CLI result is more important than run-state sync. Keep failures visible
+            // through the main result path when run creation fails.
         }
-        // No existing onClientEntry: create minimal file content or prepend to existing
-        const block = `export const onClientEntry = () => {\n  const apiKey = process.env.GATSBY_HUMANBEHAVIOR_API_KEY;\n  if (apiKey) {\n    HumanBehaviorTracker.init(apiKey);\n  }\n};`;
-        const header = content.trim() ? `${importStatement}\n` : `${importStatement}\n`;
-        return `${header}${block}${content.trim() ? `\n\n${content}` : ''}`;
     }
-    /**
-     * Helper method to find the best environment file for a framework
-     */
-    findBestEnvFile(framework) {
-        const possibleEnvFiles = [
-            '.env.local',
-            '.env.development.local',
-            '.env.development',
-            '.env.local.development',
-            '.env',
-            '.env.production',
-            '.env.staging'
-        ];
-        // Framework-specific environment variable names
-        const getEnvVarName = (framework) => {
-            // Handle React+Vite specifically
-            if (framework.type === 'react' && framework.bundler === 'vite') {
-                return 'VITE_HUMANBEHAVIOR_API_KEY';
-            }
-            // Framework-specific mappings
-            const envVarNames = {
-                react: 'REACT_APP_HUMANBEHAVIOR_API_KEY',
-                nextjs: 'NEXT_PUBLIC_HUMANBEHAVIOR_API_KEY',
-                vue: 'VITE_HUMANBEHAVIOR_API_KEY',
-                svelte: 'PUBLIC_HUMANBEHAVIOR_API_KEY',
-                angular: 'HUMANBEHAVIOR_API_KEY',
-                nuxt: 'NUXT_PUBLIC_HUMANBEHAVIOR_API_KEY',
-                remix: 'HUMANBEHAVIOR_API_KEY',
-                vanilla: 'HUMANBEHAVIOR_API_KEY',
-                astro: 'PUBLIC_HUMANBEHAVIOR_API_KEY',
-                gatsby: 'GATSBY_HUMANBEHAVIOR_API_KEY',
-                node: 'HUMANBEHAVIOR_API_KEY',
-                auto: 'HUMANBEHAVIOR_API_KEY'
-            };
-            return envVarNames[framework.type] || 'HUMANBEHAVIOR_API_KEY';
-        };
-        const envVarName = getEnvVarName(framework);
-        // Check for existing files
-        for (const envFile of possibleEnvFiles) {
-            const fullPath = path.join(this.projectRoot, envFile);
-            if (fs.existsSync(fullPath)) {
-                return { filePath: fullPath, envVarName };
-            }
-        }
-        // Framework-specific default file creation
-        const defaultFiles = {
-            react: '.env.local',
-            nextjs: '.env.local',
-            vue: '.env.local',
-            svelte: '.env',
-            angular: '.env',
-            nuxt: '.env',
-            remix: '.env.local',
-            vanilla: '.env',
-            astro: '.env',
-            gatsby: '.env.development',
-            node: '.env',
-            auto: '.env'
-        };
-        const defaultFile = defaultFiles[framework.type] || '.env';
+    failure(repo, error, dashboardUrl) {
         return {
-            filePath: path.join(this.projectRoot, defaultFile),
-            envVarName
+            success: false,
+            phase: 'analyze',
+            repo,
+            errors: [error],
+            nextSteps: [
+                'No files were changed.',
+                'Please follow the manual installation docs while the agent installer is unavailable.',
+                ...(dashboardUrl ? [`Dashboard run: ${dashboardUrl}`] : []),
+                `Manual setup docs: ${MANUAL_DOCS_URL}`
+            ],
+            dashboardUrl
         };
     }
-    /**
-     * Helper method to create or append to environment files
-     */
-    createEnvironmentModification(framework) {
-        const { filePath, envVarName } = this.findBestEnvFile(framework);
-        // Clean the API key to prevent formatting issues
-        const cleanApiKey = this.apiKey.trim();
-        if (fs.existsSync(filePath)) {
-            // Check if the variable already exists
-            const content = fs.readFileSync(filePath, 'utf8');
-            if (content.includes(envVarName)) {
-                // Variable exists, don't modify
-                return {
-                    filePath,
-                    action: 'modify',
-                    content: content, // No change
-                    description: `API key already exists in ${path.basename(filePath)}`
-                };
-            }
-            else {
-                // Append to existing file
-                return {
-                    filePath,
-                    action: 'append',
-                    content: `\n${envVarName}=${cleanApiKey}`,
-                    description: `Added API key to existing ${path.basename(filePath)}`
-                };
-            }
-        }
-        else {
-            // Create new file
-            return {
-                filePath,
-                action: 'create',
-                content: `${envVarName}=${cleanApiKey}`,
-                description: `Created ${path.basename(filePath)} with API key`
-            };
-        }
-    }
-}
-
-/**
- * Remote AI Service Implementation
- *
- * This connects to your deployed Lambda function via API Gateway
- */
-class RemoteAIService {
-    constructor(config) {
-        this.config = {
-            timeout: 10000, // 10 seconds
-            ...config
+    scanRepo() {
+        const packageJsonPaths = this.findPackageJsonPaths(this.projectPath);
+        return {
+            projectPath: this.projectPath,
+            packageManager: this.detectPackageManager(this.projectPath),
+            workspaceShape: this.detectWorkspaceShape(packageJsonPaths),
+            packageJsonPaths
         };
     }
-    /**
-     * Analyze code patterns using your deployed AI service
-     */
-    async analyzeCodePatterns(codeSamples) {
-        try {
-            const response = await fetch(`${this.config.apiEndpoint}/analyze`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ codeSamples }),
-                signal: AbortSignal.timeout(this.config.timeout || 10000)
-            });
-            if (!response.ok) {
-                throw new Error(`AI service returned ${response.status}: ${response.statusText}`);
+    findPackageJsonPaths(root) {
+        const results = [];
+        const ignoredDirs = new Set(['.git', '.next', 'dist', 'build', 'coverage', 'node_modules']);
+        const visit = (dir, depth) => {
+            if (depth > 4)
+                return;
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
             }
-            const result = await response.json();
-            return result.analysis;
-        }
-        catch (error) {
-            console.warn('Remote AI service failed, falling back to heuristic analysis:', error);
-            return this.performHeuristicAnalysis(codeSamples);
-        }
-    }
-    /**
-     * Resolve conflicts using your deployed AI service
-     */
-    async resolveConflicts(conflicts, framework) {
-        try {
-            const response = await fetch(`${this.config.apiEndpoint}/resolve-conflicts`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ conflicts, framework }),
-                signal: AbortSignal.timeout(this.config.timeout || 10000)
-            });
-            if (!response.ok) {
-                throw new Error(`AI service returned ${response.status}: ${response.statusText}`);
+            catch {
+                return;
             }
-            const result = await response.json();
-            return result.resolutions || [];
-        }
-        catch (error) {
-            console.warn('Remote AI conflict resolution failed, using heuristic approach:', error);
-            return this.resolveConflictsHeuristic(conflicts, framework);
-        }
-    }
-    /**
-     * Generate optimizations using your deployed AI service
-     */
-    async generateOptimizations(framework, patterns) {
-        try {
-            const response = await fetch(`${this.config.apiEndpoint}/optimize`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify({ framework, patterns }),
-                signal: AbortSignal.timeout(this.config.timeout || 10000)
-            });
-            if (!response.ok) {
-                throw new Error(`AI service returned ${response.status}: ${response.statusText}`);
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isFile() && entry.name === 'package.json') {
+                    results.push(path.relative(root, fullPath) || 'package.json');
+                    continue;
+                }
+                if (entry.isDirectory() && !ignoredDirs.has(entry.name) && !entry.name.startsWith('.')) {
+                    visit(fullPath, depth + 1);
+                }
             }
-            const result = await response.json();
-            return result.optimizations || [];
-        }
-        catch (error) {
-            console.warn('Remote AI optimization generation failed, using heuristic approach:', error);
-            return this.generateOptimizationsHeuristic(framework, patterns);
-        }
-    }
-    /**
-     * Heuristic analysis fallback
-     */
-    performHeuristicAnalysis(codeSamples) {
-        const patterns = codeSamples.join(' ').toLowerCase();
-        // Framework detection
-        let framework = { name: 'vanilla', type: 'vanilla' };
-        let confidence = 0.5;
-        if (patterns.includes('nuxt') || patterns.includes('nuxtjs') || patterns.includes('defineNuxtConfig') || patterns.includes('nuxt.config') || patterns.includes('@nuxt/') || patterns.includes('useNuxtApp') || patterns.includes('useRuntimeConfig') || patterns.includes('useSeoMeta') || patterns.includes('useHead') || patterns.includes('useLazyFetch') || patterns.includes('useFetch') || patterns.includes('useAsyncData') || patterns.includes('#app')) {
-            framework = { name: 'nuxt', type: 'nuxt' };
-            confidence = 0.95;
-        }
-        else if (patterns.includes('next') || patterns.includes('nextjs') || patterns.includes('next/link') || patterns.includes('next/image') || patterns.includes('next/navigation') || patterns.includes('next/router') || patterns.includes('getserverSideProps') || patterns.includes('getstaticProps') || patterns.includes('getstaticPaths') || patterns.includes('app/layout') || patterns.includes('app/page') || patterns.includes('pages/')) {
-            framework = { name: 'nextjs', type: 'nextjs' };
-            confidence = 0.95;
-        }
-        else if (patterns.includes('gatsby') || patterns.includes('gatsby-browser') || patterns.includes('gatsby-ssr') || patterns.includes('gatsby-node') || patterns.includes('gatsby-config') || patterns.includes('useStaticQuery') || patterns.includes('graphql')) {
-            framework = { name: 'gatsby', type: 'gatsby' };
-            confidence = 0.95;
-        }
-        else if (patterns.includes('react')) {
-            framework = { name: 'react', type: 'react' };
-            confidence = 0.9;
-        }
-        else if (patterns.includes('vue')) {
-            framework = { name: 'vue', type: 'vue' };
-            confidence = 0.9;
-        }
-        else if (patterns.includes('angular')) {
-            framework = { name: 'angular', type: 'angular' };
-            confidence = 0.9;
-        }
-        else if (patterns.includes('svelte')) {
-            framework = { name: 'svelte', type: 'svelte' };
-            confidence = 0.9;
-        }
-        else if (patterns.includes('astro')) {
-            framework = { name: 'astro', type: 'astro' };
-            confidence = 0.9;
-        }
-        // Integration strategy
-        let integrationStrategy = 'script';
-        if (framework.type === 'react' || framework.type === 'nextjs' || framework.type === 'gatsby') {
-            integrationStrategy = 'provider';
-        }
-        else if (framework.type === 'vue') {
-            integrationStrategy = 'plugin';
-        }
-        else if (framework.type === 'angular') {
-            integrationStrategy = 'module';
-        }
-        // Compatibility mode
-        let compatibilityMode = 'modern';
-        if (patterns.includes('require(') || patterns.includes('var ')) {
-            compatibilityMode = 'legacy';
-        }
-        return {
-            framework,
-            confidence,
-            patterns: codeSamples,
-            conflicts: [],
-            recommendations: [],
-            integrationStrategy,
-            compatibilityMode
         };
+        visit(root, 0);
+        return results.sort();
     }
-    /**
-     * Heuristic conflict resolution
-     */
-    resolveConflictsHeuristic(conflicts, framework) {
-        const resolutions = [];
-        for (const conflict of conflicts) {
-            switch (conflict) {
-                case 'existing_humanbehavior_code':
-                    resolutions.push('update_existing_integration');
-                    break;
-                case 'existing_provider':
-                    resolutions.push('merge_providers');
-                    break;
-                case 'module_system_conflict':
-                    resolutions.push('hybrid_module_support');
-                    break;
-                default:
-                    resolutions.push('skip_conflict');
-            }
+    detectPackageManager(root) {
+        if (fs.existsSync(path.join(root, 'bun.lockb')) || fs.existsSync(path.join(root, 'bun.lock'))) {
+            return 'bun';
         }
-        return resolutions;
-    }
-    /**
-     * Heuristic optimization generation
-     */
-    generateOptimizationsHeuristic(framework, patterns) {
-        const optimizations = [];
-        switch (framework.type) {
-            case 'react':
-                optimizations.push('Use React.memo for performance optimization');
-                optimizations.push('Implement error boundaries for better error tracking');
-                optimizations.push('Consider using React.lazy for code splitting');
-                break;
-            case 'vue':
-                optimizations.push('Use Vue 3 Composition API for better performance');
-                optimizations.push('Implement proper error handling in components');
-                optimizations.push('Consider using Vue Router for navigation tracking');
-                break;
-            case 'angular':
-                optimizations.push('Use Angular standalone components for better tree-shaking');
-                optimizations.push('Implement proper error handling with ErrorHandler');
-                optimizations.push('Consider using Angular signals for state management');
-                break;
-            default:
-                optimizations.push('Enable performance tracking');
-                optimizations.push('Implement error tracking');
-                optimizations.push('Consider progressive enhancement');
+        if (fs.existsSync(path.join(root, 'pnpm-lock.yaml'))) {
+            return 'pnpm';
         }
-        return optimizations;
-    }
-}
-
-/**
- * Manual Framework Installation Wizard
- *
- * This wizard allows users to manually specify their framework instead of auto-detection.
- * Useful when auto-detection fails or users want more control.
- */
-class ManualFrameworkInstallationWizard extends AutoInstallationWizard {
-    constructor(apiKey, projectRoot = process.cwd(), framework) {
-        super(apiKey, projectRoot);
-        this.selectedFramework = framework.toLowerCase();
-        this.framework = this.createFrameworkInfo(this.selectedFramework);
-    }
-    /**
-     * Manual installation with user-specified framework
-     */
-    async install() {
-        try {
-            // Step 1: Handle framework selection
-            if (this.selectedFramework === 'auto') {
-                // Use full AI detection for "Other" option
-                this.framework = await this.runFullDetection();
-            }
-            else {
-                // Set framework based on user selection
-                this.framework = this.createFrameworkInfo(this.selectedFramework);
-                if (!this.framework) {
-                    this.framework = { name: 'unknown', type: 'vanilla' };
-                }
-                // Step 2: Run full detection logic to find entry points, file names, etc.
-                const detectedFramework = await this.runFullDetection();
-                // Step 3: Merge manual framework with detected details
-                this.framework = {
-                    ...detectedFramework,
-                    name: this.framework.name,
-                    type: this.framework.type
-                };
+        if (fs.existsSync(path.join(root, 'yarn.lock'))) {
+            if (fs.existsSync(path.join(root, '.yarnrc.yml')) || fs.existsSync(path.join(root, '.pnp.cjs'))) {
+                return 'yarn-berry';
             }
-            // Step 4: Install package
-            await this.installPackage();
-            // Step 5: Generate and apply code modifications
-            const modifications = await this.generateModifications();
-            await this.applyModifications(modifications);
-            // Step 6: Generate next steps
-            const nextSteps = this.generateManualNextSteps();
-            return {
-                success: true,
-                framework: this.framework,
-                modifications,
-                errors: [],
-                nextSteps,
-                selectedFramework: this.selectedFramework,
-                manualMode: true
-            };
+            return 'yarn-classic';
         }
-        catch (error) {
-            return {
-                success: false,
-                framework: this.framework || { name: 'unknown', type: 'vanilla' },
-                modifications: [],
-                errors: [error instanceof Error ? error.message : 'Unknown error'],
-                nextSteps: [],
-                selectedFramework: this.selectedFramework,
-                manualMode: true
-            };
+        if (fs.existsSync(path.join(root, 'package-lock.json'))) {
+            return 'npm';
         }
+        return 'unknown';
     }
-    /**
-     * Run full detection logic to find entry points, file names, bundler, etc.
-     */
-    async runFullDetection() {
-        if (this.selectedFramework === 'auto') {
-            // Use AI service for auto-detection
-            const aiService = new RemoteAIService({
-                apiEndpoint: 'https://ik3zxh4790.execute-api.us-east-1.amazonaws.com/prod'
-            });
-            // Use AI service directly for detection
-            const projectFiles = await this.scanProjectFiles();
-            const codeSamples = await this.extractCodeSamples(projectFiles);
-            const aiAnalysis = await aiService.analyzeCodePatterns(codeSamples);
-            return aiAnalysis.framework;
+    detectWorkspaceShape(packageJsonPaths) {
+        if (packageJsonPaths.length === 0) {
+            return 'unknown';
         }
-        else {
-            // Use traditional detection for manual frameworks
-            const tempWizard = new AutoInstallationWizard(this.apiKey, this.projectRoot);
-            const detected = await tempWizard.detectFramework();
-            return detected;
+        if (packageJsonPaths.length === 1) {
+            return 'single-app';
         }
-    }
-    /**
-     * Scan project files for analysis
-     */
-    async scanProjectFiles() {
-        const files = [];
-        const scanDir = (dir, depth = 0) => {
-            if (depth > 3)
-                return; // Limit depth
-            try {
-                const items = fs.readdirSync(dir);
-                for (const item of items) {
-                    const fullPath = path.join(dir, item);
-                    const stat = fs.statSync(fullPath);
-                    if (stat.isDirectory() && !item.startsWith('.') && item !== 'node_modules') {
-                        scanDir(fullPath, depth + 1);
-                    }
-                    else if (stat.isFile() && this.isRelevantFile(item)) {
-                        files.push(fullPath);
-                    }
-                }
-            }
-            catch (error) {
-                // Skip inaccessible directories
-            }
-        };
-        scanDir(this.projectRoot);
-        return files;
-    }
-    /**
-     * Check if file is relevant for analysis
-     */
-    isRelevantFile(filename) {
-        const relevantExtensions = [
-            '.js', '.jsx', '.ts', '.tsx', '.vue', '.svelte', '.html',
-            '.json', '.config.js', '.config.ts', '.babelrc', '.eslintrc'
-        ];
-        const relevantNames = [
-            'package.json', 'tsconfig.json', 'vite.config', 'webpack.config',
-            'next.config', 'nuxt.config', 'angular.json', 'svelte.config'
-        ];
-        return relevantExtensions.some(ext => filename.endsWith(ext)) ||
-            relevantNames.some(name => filename.includes(name));
-    }
-    /**
-     * Extract code samples for AI analysis
-     */
-    async extractCodeSamples(files) {
-        const samples = [];
-        for (const file of files.slice(0, 20)) { // Limit to 20 files
-            try {
-                const content = fs.readFileSync(file, 'utf8');
-                const relativePath = path.relative(this.projectRoot, file);
-                samples.push(`File: ${relativePath}\n${content.substring(0, 1000)}`);
-            }
-            catch (error) {
-                // Skip unreadable files
-            }
-        }
-        return samples;
-    }
-    /**
-     * Create framework info based on user selection
-     */
-    createFrameworkInfo(framework) {
-        const frameworkMap = {
-            'react': { name: 'react', type: 'react' },
-            'nextjs': { name: 'nextjs', type: 'nextjs' },
-            'next': { name: 'nextjs', type: 'nextjs' },
-            'vue': { name: 'vue', type: 'vue' },
-            'nuxt': { name: 'nuxt', type: 'nuxt' },
-            'nuxtjs': { name: 'nuxt', type: 'nuxt' },
-            'angular': { name: 'angular', type: 'angular' },
-            'svelte': { name: 'svelte', type: 'svelte' },
-            'sveltekit': { name: 'svelte', type: 'svelte' },
-            'remix': { name: 'remix', type: 'remix' },
-            'astro': { name: 'astro', type: 'astro' },
-            'gatsby': { name: 'gatsby', type: 'gatsby' },
-            'vanilla': { name: 'vanilla', type: 'vanilla' },
-            'node': { name: 'node', type: 'node' },
-            'auto': { name: 'auto-detected', type: 'auto' }
-        };
-        return frameworkMap[framework] || { name: framework, type: 'vanilla' };
-    }
-    /**
-     * Override framework detection to use manual selection
-     */
-    async detectFramework() {
-        return this.framework || { name: 'unknown', type: 'vanilla' };
-    }
-    /**
-     * Generate next steps with manual mode info
-     */
-    generateManualNextSteps() {
-        return [
-            '✅ Manual framework installation completed!',
-            `🎯 Selected framework: ${this.framework?.name || 'unknown'}`,
-            `🔧 Integration strategy: ${this.getIntegrationStrategy()}`,
-            '🚀 Your app is now ready to track user behavior',
-            '📊 View sessions in your HumanBehavior dashboard'
-        ];
-    }
-    /**
-     * Get integration strategy based on framework
-     */
-    getIntegrationStrategy() {
-        if (!this.framework?.type)
-            return 'script';
-        switch (this.framework.type) {
-            case 'react':
-            case 'nextjs':
-                return 'provider';
-            case 'vue':
-                return 'plugin';
-            case 'angular':
-                return 'module';
-            default:
-                return 'script';
+        if (packageJsonPaths.length <= 4) {
+            return 'simple-monorepo';
         }
+        return 'complex-monorepo';
     }
 }
 
 /**
- * AI-Enhanced HumanBehavior SDK Auto-Installation CLI
+ * HumanBehavior managed agent installation CLI.
  *
- * Usage: npx humanbehavior-js ai-auto-install [api-key]
- *
- * This tool uses AI to intelligently detect frameworks, analyze code patterns,
- * and generate optimal integration code that's both future-proof and backward-compatible.
+ * This entrypoint intentionally does not fall back to the old heuristic
+ * installer. If the managed agent is unavailable, it fails closed and points
+ * users to manual docs instead of making lower-confidence edits.
  */
 class AIAutoInstallCLI {
     constructor(options) {
         this.options = options;
     }
     async run() {
-        clack.intro('🤖 AI-Enhanced HumanBehavior SDK Auto-Installation');
+        clack.intro('HumanBehavior Agent Installer');
         try {
-            // Get API key
             const apiKey = await this.getApiKey();
             if (!apiKey) {
                 clack.cancel('API key is required');
                 process.exit(1);
             }
-            // Get project path
             const projectPath = this.options.projectPath || process.cwd();
-            // Choose framework
-            const framework = await this.chooseFramework();
-            if (!framework) {
-                clack.cancel('Installation cancelled.');
-                process.exit(0);
-            }
-            // Confirm installation
             if (!this.options.yes) {
-                const confirmed = await this.confirmInstallation(projectPath, framework);
+                const confirmed = await this.confirmInstallation(projectPath);
                 if (!confirmed) {
                     clack.cancel('Installation cancelled.');
                     process.exit(0);
                 }
             }
-            // Run installation
             const spinner = clack.spinner();
-            spinner.start('🔍 Analyzing your project with AI...');
-            const wizard = new ManualFrameworkInstallationWizard(apiKey, projectPath, framework);
-            const result = await wizard.install();
-            spinner.stop('Analysis complete!');
-            // Display results
-            this.displayResults(result, framework);
+            spinner.start(this.options.dryRun ? 'Scanning project...' : 'Starting managed agent installer...');
+            const runner = new AgentInstallationRunner({
+                apiKey,
+                projectPath,
+                executionMode: this.getExecutionMode(),
+                appUrl: this.options.appUrl,
+                ingestionUrl: this.options.ingestionUrl
+            });
+            const result = await runner.run();
+            spinner.stop(this.options.dryRun ? 'Scan complete.' : 'Agent installer finished.');
+            this.displayResults(result);
         }
         catch (error) {
             clack.cancel(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -1908,58 +639,41 @@ class AIAutoInstallCLI {
         });
         return apiKey;
     }
-    async confirmInstallation(projectPath, framework) {
+    getExecutionMode() {
+        if (this.options.dryRun)
+            return 'dry-run';
+        if (this.options.yes)
+            return 'yes';
+        return 'interactive';
+    }
+    async confirmInstallation(projectPath) {
         const confirmed = await clack.confirm({
-            message: `Ready to install HumanBehavior SDK in ${projectPath} for ${framework}?`
+            message: `Ready to run the HumanBehavior agent installer in ${projectPath}?`
         });
         return confirmed;
     }
-    async chooseFramework() {
-        const framework = await clack.select({
-            message: 'Select your framework:',
-            options: [
-                { label: 'React', value: 'react' },
-                { label: 'Next.js', value: 'nextjs' },
-                { label: 'Vue', value: 'vue' },
-                { label: 'Angular', value: 'angular' },
-                { label: 'Svelte', value: 'svelte' },
-                { label: 'Nuxt.js', value: 'nuxt' },
-                { label: 'Remix', value: 'remix' },
-                { label: 'Astro', value: 'astro' },
-                { label: 'Gatsby', value: 'gatsby' },
-                { label: 'Vanilla JS/TS', value: 'vanilla' }
-            ]
-        });
-        return framework;
-    }
-    displayResults(result, framework) {
+    displayResults(result) {
+        clack.note([
+            `Project path: ${result.repo.projectPath}`,
+            `Package manager: ${result.repo.packageManager}`,
+            `Workspace shape: ${result.repo.workspaceShape}`,
+            `package.json files: ${result.repo.packageJsonPaths.length || 'none'}`
+        ].join('\n'), 'Project Scan');
         if (result.success) {
-            clack.outro('🎉 Installation completed successfully!');
-            // Display framework info
-            clack.note(`Framework detected: ${result.framework.name} (${result.framework.type})`, 'Framework Info');
-            // Display modifications
-            if (result.modifications && result.modifications.length > 0) {
-                const modifications = result.modifications.map((mod) => `${mod.action}: ${mod.filePath} - ${mod.description}`);
-                clack.note(modifications.join('\n'), 'Files Modified');
-            }
-            // Display next steps
-            if (result.nextSteps && result.nextSteps.length > 0) {
+            if (result.nextSteps.length > 0) {
                 clack.note(result.nextSteps.join('\n'), 'Next Steps');
             }
-            // Display AI insights if available
-            if (result.aiAnalysis) {
-                clack.note(`Confidence: ${Math.round(result.aiAnalysis.confidence * 100)}%`, 'AI Analysis');
-                if (result.aiAnalysis.recommendations && result.aiAnalysis.recommendations.length > 0) {
-                    clack.note(result.aiAnalysis.recommendations.join('\n'), 'AI Recommendations');
-                }
-            }
+            clack.outro(this.options.dryRun ? 'Dry run complete.' : 'Installation completed successfully.');
+            return;
         }
-        else {
-            clack.cancel('Installation failed');
-            if (result.errors && result.errors.length > 0) {
-                clack.note(result.errors.join('\n'), 'Errors');
-            }
+        if (result.errors.length > 0) {
+            clack.note(result.errors.join('\n'), 'Errors');
         }
+        if (result.nextSteps.length > 0) {
+            clack.note(result.nextSteps.join('\n'), 'Next Steps');
+        }
+        clack.cancel('Agent installer unavailable.');
+        process.exit(1);
     }
 }
 function parseArgs() {
@@ -1984,16 +698,19 @@ function parseArgs() {
             case '-p':
                 options.projectPath = args[++i];
                 break;
+            case '--app-url':
+                options.appUrl = args[++i];
+                break;
+            case '--ingestion-url':
+                options.ingestionUrl = args[++i];
+                break;
             case '--framework':
             case '-f':
-                options.framework = args[++i];
-                break;
+                throw new Error('--framework is no longer supported. The agent installer scans the project automatically.');
             case 'init':
-                if (!args[i + 1] || args[i + 1].startsWith('-')) {
-                    showInitHelp();
-                    process.exit(1);
+                if (args[i + 1] && !args[i + 1].startsWith('-')) {
+                    options.apiKey = args[++i];
                 }
-                options.apiKey = args[++i];
                 break;
             default:
                 if (!options.apiKey && !arg.startsWith('-')) {
@@ -2006,43 +723,33 @@ function parseArgs() {
 }
 function showHelp() {
     console.log(`
-🤖 HumanBehavior SDK AI Auto-Installation
+HumanBehavior Agent Installer
 
-Usage: npx humanbehavior-js ai-auto-install [api-key] [options]
+Usage: npx humanbehavior-js init [api-key] [options]
 
 Options:
   -h, --help              Show this help message
-  -y, --yes               Skip all prompts and use defaults
-  --dry-run               Show what would be changed without making changes
-
+  -y, --yes               Skip confirmation prompts
+  --dry-run               Scan and report without changing files
   -p, --project <path>    Specify project directory
-  -f, --framework <name>  Specify framework manually
-
-Examples:
-  npx humanbehavior-js ai-auto-install
-  npx humanbehavior-js ai-auto-install hb_your_api_key_here
-  npx humanbehavior-js ai-auto-install --project ./my-app --ai
-  npx humanbehavior-js ai-auto-install --framework react --yes
-`);
-}
-function showInitHelp() {
-    console.log(`
-Usage: npx humanbehavior-js init <api-key>
-
-Arguments:
-  api-key    Your HumanBehavior API key (required, starts with "hb_")
+  --app-url <url>         HumanBehavior app URL for local/dev testing
+  --ingestion-url <url>   HumanBehavior ingestion URL for local/dev testing
 
 Examples:
+  npx humanbehavior-js init
   npx humanbehavior-js init hb_your_api_key_here
+  npx humanbehavior-js init --project ./my-app --yes
 `);
 }
-// Main execution
-const options = parseArgs();
-const cli = new AIAutoInstallCLI(options);
-cli.run().catch((error) => {
-    clack.cancel(`Unexpected error: ${error.message}`);
-    process.exit(1);
-});
+const isMain = import.meta.url === `file://${process.argv[1]}`;
+if (isMain) {
+    const options = parseArgs();
+    const cli = new AIAutoInstallCLI(options);
+    cli.run().catch((error) => {
+        clack.cancel(`Unexpected error: ${error.message}`);
+        process.exit(1);
+    });
+}
 
 export { AIAutoInstallCLI };
 //# sourceMappingURL=ai-auto-install.js.map