edsger 0.36.0 → 0.36.2

package/dist/commands/build/__tests__/detect-project.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Unit tests for the AI build plan module.
+ * Tests the directory tree builder, response parser, and command whitelist
+ * without real AI calls.
+ */
+export {};

package/dist/commands/build/__tests__/detect-project.test.js

@@ -0,0 +1,160 @@
+/**
+ * Unit tests for the AI build plan module.
+ * Tests the directory tree builder, response parser, and command whitelist
+ * without real AI calls.
+ */
+import assert from 'node:assert';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+import { buildDirectoryTree, parseBuildPlan, validateInstallSteps, } from '../detect-project.js';
+// ── Helpers ────────────────────────────────────────────────────────
+function createTmpDir() {
+    const dir = join(tmpdir(), `edsger-detect-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+// ── buildDirectoryTree ─────────────────────────────────────────────
+describe('buildDirectoryTree', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = createTmpDir();
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('builds a tree for a React Native structure', () => {
+        mkdirSync(join(tmpDir, 'ios', 'MyApp.xcworkspace'), { recursive: true });
+        mkdirSync(join(tmpDir, 'ios', 'MyApp.xcodeproj'), { recursive: true });
+        mkdirSync(join(tmpDir, 'android'), { recursive: true });
+        mkdirSync(join(tmpDir, 'src'), { recursive: true });
+        writeFileSync(join(tmpDir, 'package.json'), '{}');
+        writeFileSync(join(tmpDir, 'ios', 'Podfile'), '');
+        const tree = buildDirectoryTree(tmpDir, 2);
+        assert.ok(tree.includes('ios/'));
+        assert.ok(tree.includes('MyApp.xcworkspace/'));
+        assert.ok(tree.includes('package.json'));
+    });
+    it('excludes node_modules and Pods', () => {
+        mkdirSync(join(tmpDir, 'node_modules', 'pkg'), { recursive: true });
+        mkdirSync(join(tmpDir, 'ios', 'Pods'), { recursive: true });
+        mkdirSync(join(tmpDir, 'src'), { recursive: true });
+        const tree = buildDirectoryTree(tmpDir);
+        assert.ok(!tree.includes('node_modules'));
+        assert.ok(!tree.includes('Pods'));
+        assert.ok(tree.includes('src/'));
+    });
+    it('respects max depth', () => {
+        mkdirSync(join(tmpDir, 'a', 'b', 'c', 'd', 'e'), { recursive: true });
+        writeFileSync(join(tmpDir, 'a', 'b', 'c', 'd', 'e', 'deep.txt'), '');
+        const tree = buildDirectoryTree(tmpDir, 2);
+        assert.ok(!tree.includes('deep.txt'));
+    });
+    it('returns empty string for empty directory', () => {
+        assert.strictEqual(buildDirectoryTree(tmpDir), '');
+    });
+});
+// ── parseBuildPlan ─────────────────────────────────────────────────
+describe('parseBuildPlan', () => {
+    it('parses a valid JSON response with code block', () => {
+        const response = `\`\`\`json
+{
+  "build_plan": {
+    "project_type": "react-native",
+    "install_steps": [
+      { "cmd": "npm", "args": ["ci"], "cwd": "" },
+      { "cmd": "pod", "args": ["install"], "cwd": "ios" }
+    ],
+    "project_path": "ios/MyApp.xcworkspace",
+    "scheme_hint": "MyApp",
+    "reasoning": "React Native project with CocoaPods"
+  }
+}
+\`\`\``;
+        const plan = parseBuildPlan(response);
+        assert.ok(plan);
+        assert.strictEqual(plan.projectType, 'react-native');
+        assert.strictEqual(plan.projectPath, 'ios/MyApp.xcworkspace');
+        assert.strictEqual(plan.schemeHint, 'MyApp');
+        assert.strictEqual(plan.installSteps.length, 2);
+        assert.strictEqual(plan.installSteps[0].cmd, 'npm');
+        assert.strictEqual(plan.installSteps[1].cmd, 'pod');
+        assert.strictEqual(plan.installSteps[1].cwd, 'ios');
+    });
+    it('parses raw JSON without code block', () => {
+        const response = JSON.stringify({
+            build_plan: {
+                project_type: 'native',
+                install_steps: [],
+                project_path: 'App.xcodeproj',
+                scheme_hint: 'App',
+                reasoning: 'Simple native project',
+            },
+        });
+        const plan = parseBuildPlan(response);
+        assert.ok(plan);
+        assert.strictEqual(plan.projectType, 'native');
+        assert.strictEqual(plan.installSteps.length, 0);
+    });
+    it('returns null for empty project_path', () => {
+        const response = JSON.stringify({
+            build_plan: {
+                project_type: 'native',
+                install_steps: [],
+                project_path: '',
+                scheme_hint: '',
+                reasoning: '',
+            },
+        });
+        assert.strictEqual(parseBuildPlan(response), null);
+    });
+    it('returns null for garbage input', () => {
+        assert.strictEqual(parseBuildPlan('not json at all'), null);
+    });
+    it('handles missing optional fields gracefully', () => {
+        const response = JSON.stringify({
+            build_plan: {
+                project_type: 'flutter',
+                project_path: 'ios/Runner.xcworkspace',
+            },
+        });
+        const plan = parseBuildPlan(response);
+        assert.ok(plan);
+        assert.strictEqual(plan.schemeHint, '');
+        assert.strictEqual(plan.installSteps.length, 0);
+    });
+});
+// ── validateInstallSteps ───────────────────────────────────────────
+describe('validateInstallSteps', () => {
+    it('allows known safe commands', () => {
+        const steps = [
+            { cmd: 'npm', args: ['ci'], cwd: '' },
+            { cmd: 'yarn', args: ['install'], cwd: '' },
+            { cmd: 'pod', args: ['install'], cwd: 'ios' },
+            { cmd: 'flutter', args: ['pub', 'get'], cwd: '' },
+            { cmd: 'xcodegen', args: ['generate'], cwd: '' },
+            { cmd: 'tuist', args: ['generate'], cwd: '' },
+            { cmd: 'bundle', args: ['install'], cwd: '' },
+        ];
+        const valid = validateInstallSteps(steps);
+        assert.strictEqual(valid.length, 7);
+    });
+    it('filters out disallowed commands', () => {
+        const steps = [
+            { cmd: 'npm', args: ['ci'], cwd: '' },
+            { cmd: 'rm', args: ['-rf', '/'], cwd: '' },
+            { cmd: 'curl', args: ['http://evil.com'], cwd: '' },
+            { cmd: 'pod', args: ['install'], cwd: 'ios' },
+        ];
+        const valid = validateInstallSteps(steps);
+        assert.strictEqual(valid.length, 2);
+        assert.strictEqual(valid[0].cmd, 'npm');
+        assert.strictEqual(valid[1].cmd, 'pod');
+    });
+    it('returns empty array for all-disallowed steps', () => {
+        const steps = [{ cmd: 'bash', args: ['-c', 'echo pwned'], cwd: '' }];
+        const valid = validateInstallSteps(steps);
+        assert.strictEqual(valid.length, 0);
+    });
+});

package/dist/commands/build/__tests__/run-build.test.js

@@ -48,6 +48,22 @@ function makeOptions(overrides = {}) {
         ...overrides,
     };
 }
+const DEFAULT_PRODUCT = {
+    id: 'prod-1',
+    name: 'My App',
+    description: 'A test application',
+};
+/** Default mock build plan for a React Native project */
+const DEFAULT_PLAN = {
+    projectType: 'react-native',
+    installSteps: [
+        { cmd: 'npm', args: ['ci'], cwd: '' },
+        { cmd: 'pod', args: ['install'], cwd: 'ios' },
+    ],
+    projectPath: 'ios/MyApp.xcworkspace',
+    schemeHint: 'MyApp',
+    reasoning: 'Mock plan',
+};
 function createMockDeps(overrides = {}) {
     const calls = [];
     const savedConfigs = [];
@@ -56,9 +72,13 @@ function createMockDeps(overrides = {}) {
     const exportDir = join(tmpDir, 'build', 'export');
     mkdirSync(exportDir, { recursive: true });
     writeFileSync(join(exportDir, 'MyApp.ipa'), 'fake-ipa-data');
+    // Create the AI-suggested project path so existsSync passes
+    mkdirSync(join(tmpDir, 'ios', 'MyApp.xcworkspace'), { recursive: true });
     const deps = {
         fetchConfigs: overrides.fetchConfigs ??
             (async () => overrides.configs ?? [makeAppleConfig()]),
+        fetchProduct: overrides.fetchProduct ??
+            (async () => overrides.product ?? DEFAULT_PRODUCT),
         fetchGitHub: overrides.fetchGitHub ??
             (async () => ({
                 configured: true,
@@ -74,9 +94,10 @@ function createMockDeps(overrides = {}) {
                 return null;
             }),
         checkoutDefaultBranch: overrides.checkoutDefaultBranch ?? (() => { }),
+        analyzeBuildPlan: overrides.analyzeBuildPlan ?? (async () => DEFAULT_PLAN),
         findProjects: overrides.findProjects ??
             (() => overrides.projects ?? [
-                { path: 'MyApp.xcworkspace', type: 'workspace' },
+                { path: 'ios/MyApp.xcworkspace', type: 'workspace' },
             ]),
         findSchemes: overrides.findSchemes ?? (() => overrides.schemes ?? ['MyApp']),
         runCommand: overrides.runCommand ??
@@ -130,9 +151,10 @@ describe('runBuild orchestration', () => {
             return true;
         });
     });
-    it('throws when no Xcode projects found', async () => {
+    it('throws when AI plan fails and no projects found in fallback scan', async () => {
         const { deps } = createMockDeps({
             tmpDir,
+            analyzeBuildPlan: async () => null,
             projects: [],
         });
         await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
@@ -143,6 +165,10 @@ describe('runBuild orchestration', () => {
     it('throws when no schemes found', async () => {
         const { deps } = createMockDeps({
             tmpDir,
+            analyzeBuildPlan: async () => ({
+                ...DEFAULT_PLAN,
+                schemeHint: '', // no hint → must discover
+            }),
             schemes: [],
         });
         await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
@@ -150,52 +176,166 @@ describe('runBuild orchestration', () => {
             return true;
         });
     });
-    // -- Happy paths --
-    it('runs full archive + export pipeline', async () => {
-        const config = makeAppleConfig({
-            build_config: { team_id: 'TEAM1', export_method: 'app-store' },
+    // -- AI plan execution --
+    it('executes install steps from AI plan in order', async () => {
+        const { deps, calls } = createMockDeps({
+            tmpDir,
+            analyzeBuildPlan: async () => ({
+                projectType: 'react-native',
+                installSteps: [
+                    { cmd: 'npm', args: ['ci'], cwd: '' },
+                    { cmd: 'pod', args: ['install'], cwd: 'ios' },
+                ],
+                projectPath: 'ios/MyApp.xcworkspace',
+                schemeHint: 'MyApp',
+                reasoning: 'React Native project',
+            }),
         });
-        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
         await runBuild(makeOptions(), deps);
-        // Should have called xcodebuild twice: archive + exportArchive
-        const xcodeCalls = calls.filter((c) => c.cmd === 'xcodebuild');
-        assert.strictEqual(xcodeCalls.length, 2);
-        assert.ok(xcodeCalls[0].args.includes('archive'));
-        assert.ok(xcodeCalls[1].args.includes('-exportArchive'));
+        // Install steps should run before xcodebuild
+        const npmIdx = calls.findIndex((c) => c.cmd === 'npm');
+        const podIdx = calls.findIndex((c) => c.cmd === 'pod');
+        const xcodeIdx = calls.findIndex((c) => c.cmd === 'xcodebuild');
+        assert.ok(npmIdx >= 0, 'Expected npm call');
+        assert.ok(podIdx >= 0, 'Expected pod call');
+        assert.ok(xcodeIdx >= 0, 'Expected xcodebuild call');
+        assert.ok(npmIdx < podIdx, 'npm should run before pod');
+        assert.ok(podIdx < xcodeIdx, 'pod should run before xcodebuild');
+        // Verify cwd
+        assert.strictEqual(calls[npmIdx].opts?.cwd, tmpDir);
+        assert.strictEqual(calls[podIdx].opts?.cwd, join(tmpDir, 'ios'));
     });
-    it('uses scheme from options over saved config', async () => {
-        const config = makeAppleConfig({
-            build_config: { scheme: 'SavedScheme', project_path: 'A.xcworkspace' },
+    it('uses AI-suggested project path and scheme', async () => {
+        mkdirSync(join(tmpDir, 'apps', 'mobile', 'ios', 'Mobile.xcworkspace'), {
+            recursive: true,
         });
-        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
-        await runBuild(makeOptions({ scheme: 'OverrideScheme' }), deps);
+        const { deps, calls, savedConfigs } = createMockDeps({
+            tmpDir,
+            analyzeBuildPlan: async () => ({
+                projectType: 'react-native',
+                installSteps: [],
+                projectPath: 'apps/mobile/ios/Mobile.xcworkspace',
+                schemeHint: 'MobileApp',
+                reasoning: 'Monorepo — mobile app matches product',
+            }),
+        });
+        await runBuild(makeOptions(), deps);
+        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
+        assert.ok(archiveCall);
+        assert.ok(archiveCall.args.some((a) => a.includes('apps/mobile/ios/Mobile.xcworkspace')));
+        const schemeIdx = archiveCall.args.indexOf('-scheme');
+        assert.strictEqual(archiveCall.args[schemeIdx + 1], 'MobileApp');
+        // Verify persisted to DB
+        assert.strictEqual(savedConfigs.length, 1);
+        assert.strictEqual(savedConfigs[0].project_path, 'apps/mobile/ios/Mobile.xcworkspace');
+        assert.strictEqual(savedConfigs[0].scheme, 'MobileApp');
+    });
+    it('falls back to scan when AI-suggested project path does not exist', async () => {
+        const { deps, calls } = createMockDeps({
+            tmpDir,
+            analyzeBuildPlan: async () => ({
+                ...DEFAULT_PLAN,
+                projectPath: 'nonexistent/App.xcworkspace', // does not exist on disk
+            }),
+            projects: [{ path: 'ios/MyApp.xcworkspace', type: 'workspace' }],
+        });
+        await runBuild(makeOptions(), deps);
+        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
+        assert.ok(archiveCall);
+        // Should have fallen back to scanned project
+        assert.ok(archiveCall.args.some((a) => a.includes('ios/MyApp.xcworkspace')));
+    });
+    it('discovers scheme via xcodebuild -list when AI has no hint', async () => {
+        const { deps, calls } = createMockDeps({
+            tmpDir,
+            analyzeBuildPlan: async () => ({
+                ...DEFAULT_PLAN,
+                schemeHint: '', // empty → discover
+            }),
+            schemes: ['DiscoveredScheme'],
+        });
+        await runBuild(makeOptions(), deps);
+        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
+        assert.ok(archiveCall);
+        const schemeIdx = archiveCall.args.indexOf('-scheme');
+        assert.strictEqual(archiveCall.args[schemeIdx + 1], 'DiscoveredScheme');
+    });
+    it('falls back to scan when AI returns null (no plan)', async () => {
+        const { deps, calls } = createMockDeps({
+            tmpDir,
+            analyzeBuildPlan: async () => null,
+            projects: [{ path: 'FallbackApp.xcworkspace', type: 'workspace' }],
+            schemes: ['FallbackScheme'],
+        });
+        await runBuild(makeOptions(), deps);
+        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
+        assert.ok(archiveCall);
+        assert.ok(archiveCall.args.some((a) => a.includes('FallbackApp.xcworkspace')));
+        const schemeIdx = archiveCall.args.indexOf('-scheme');
+        assert.strictEqual(archiveCall.args[schemeIdx + 1], 'FallbackScheme');
+    });
+    it('CLI --scheme overrides AI scheme hint', async () => {
+        const { deps, calls } = createMockDeps({ tmpDir });
+        await runBuild(makeOptions({ scheme: 'ManualScheme' }), deps);
         const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
         assert.ok(archiveCall);
         const schemeIdx = archiveCall.args.indexOf('-scheme');
-        assert.strictEqual(archiveCall.args[schemeIdx + 1], 'OverrideScheme');
+        assert.strictEqual(archiveCall.args[schemeIdx + 1], 'ManualScheme');
     });
-    it('uses project path from saved build_config', async () => {
+    // -- Saved config paths (skip AI) --
+    it('skips AI when project_path and scheme are saved', async () => {
+        let aiCalled = false;
         const config = makeAppleConfig({
             build_config: { project_path: 'ios/App.xcworkspace', scheme: 'App' },
         });
-        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        const { deps, calls } = createMockDeps({
+            tmpDir,
+            configs: [config],
+            analyzeBuildPlan: async () => {
+                aiCalled = true;
+                return null;
+            },
+        });
         await runBuild(makeOptions(), deps);
+        assert.ok(!aiCalled, 'AI should NOT be called when config is saved');
         const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
         assert.ok(archiveCall);
         assert.ok(archiveCall.args.some((a) => a.includes('ios/App.xcworkspace')));
     });
-    it('persists discovered build config to DB', async () => {
-        const { deps, savedConfigs } = createMockDeps({ tmpDir });
-        await runBuild(makeOptions(), deps);
+    it('re-runs AI on --reselect even with saved config', async () => {
+        let aiCalled = false;
+        const config = makeAppleConfig({
+            build_config: {
+                project_path: 'old/Old.xcworkspace',
+                scheme: 'OldScheme',
+                configuration: 'Release',
+            },
+        });
+        mkdirSync(join(tmpDir, 'new', 'New.xcworkspace'), { recursive: true });
+        const { deps, savedConfigs } = createMockDeps({
+            tmpDir,
+            configs: [config],
+            analyzeBuildPlan: async () => {
+                aiCalled = true;
+                return {
+                    projectType: 'native',
+                    installSteps: [],
+                    projectPath: 'new/New.xcworkspace',
+                    schemeHint: 'NewScheme',
+                    reasoning: 'Redetected',
+                };
+            },
+        });
+        await runBuild(makeOptions({ reselect: true }), deps);
+        assert.ok(aiCalled, 'AI should be called on --reselect');
         assert.strictEqual(savedConfigs.length, 1);
-        assert.strictEqual(savedConfigs[0].project_path, 'MyApp.xcworkspace');
-        assert.strictEqual(savedConfigs[0].scheme, 'MyApp');
-        assert.strictEqual(savedConfigs[0].configuration, 'Release');
+        assert.strictEqual(savedConfigs[0].project_path, 'new/New.xcworkspace');
+        assert.strictEqual(savedConfigs[0].scheme, 'NewScheme');
     });
     it('does not re-save config when nothing changed', async () => {
         const config = makeAppleConfig({
             build_config: {
-                project_path: 'MyApp.xcworkspace',
+                project_path: 'ios/MyApp.xcworkspace',
                 scheme: 'MyApp',
                 configuration: 'Release',
             },
@@ -207,6 +347,23 @@ describe('runBuild orchestration', () => {
         await runBuild(makeOptions(), deps);
         assert.strictEqual(savedConfigs.length, 0);
     });
+    // -- Archive / export / upload --
+    it('runs full archive + export pipeline', async () => {
+        const config = makeAppleConfig({
+            build_config: {
+                project_path: 'A.xcworkspace',
+                scheme: 'A',
+                team_id: 'TEAM1',
+                export_method: 'app-store',
+            },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        await runBuild(makeOptions(), deps);
+        const xcodeCalls = calls.filter((c) => c.cmd === 'xcodebuild');
+        assert.strictEqual(xcodeCalls.length, 2);
+        assert.ok(xcodeCalls[0].args.includes('archive'));
+        assert.ok(xcodeCalls[1].args.includes('-exportArchive'));
+    });
     it('passes --upload to trigger upload after build', async () => {
         const config = makeAppleConfig({
             build_config: {
@@ -219,7 +376,6 @@ describe('runBuild orchestration', () => {
         });
         const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
         await runBuild(makeOptions({ upload: true }), deps);
-        // Should have xcrun altool call for upload
         const uploadCall = calls.find((c) => c.cmd === 'xcrun' && c.args.includes('altool'));
         assert.ok(uploadCall, 'Expected xcrun altool upload call');
         assert.ok(uploadCall.args.includes('--upload-app'));
@@ -240,28 +396,21 @@ describe('runBuild orchestration', () => {
         assert.ok(uploadCall, 'Expected xcrun notarytool call for macOS');
     });
     it('passes platform destination to xcodebuild', async () => {
-        const { deps, calls } = createMockDeps({ tmpDir });
+        const config = makeAppleConfig({
+            build_config: { project_path: 'A.xcworkspace', scheme: 'A' },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
         await runBuild(makeOptions({ platform: 'macos' }), deps);
         const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
         assert.ok(archiveCall);
         const destIdx = archiveCall.args.indexOf('-destination');
         assert.strictEqual(archiveCall.args[destIdx + 1], 'generic/platform=macOS');
     });
-    it('auto-selects first workspace when multiple projects exist', async () => {
-        const { deps, calls } = createMockDeps({
-            tmpDir,
-            projects: [
-                { path: 'ios/App.xcworkspace', type: 'workspace' },
-                { path: 'App.xcodeproj', type: 'project' },
-            ],
-        });
-        await runBuild(makeOptions(), deps);
-        const archiveCall = calls.find((c) => c.cmd === 'xcodebuild' && c.args.includes('archive'));
-        assert.ok(archiveCall);
-        assert.ok(archiveCall.args.some((a) => a.includes('ios/App.xcworkspace')));
-    });
     it('skips archive when --skipArchive is set', async () => {
-        const { deps, calls } = createMockDeps({ tmpDir });
+        const config = makeAppleConfig({
+            build_config: { project_path: 'A.xcworkspace', scheme: 'A' },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
         await runBuild(makeOptions({ skipArchive: true }), deps);
         const xcodeCalls = calls.filter((c) => c.cmd === 'xcodebuild');
         assert.strictEqual(xcodeCalls.length, 0);
@@ -281,23 +430,4 @@ describe('runBuild orchestration', () => {
         assert.ok(archiveCall);
         assert.ok(archiveCall.args.some((a) => a === 'DEVELOPMENT_TEAM=TEAM123'));
     });
-    it('re-discovers project on --reselect even with saved config', async () => {
-        const config = makeAppleConfig({
-            build_config: {
-                project_path: 'old/Old.xcworkspace',
-                scheme: 'OldScheme',
-                configuration: 'Release',
-            },
-        });
-        const { deps, savedConfigs } = createMockDeps({
-            tmpDir,
-            configs: [config],
-            projects: [{ path: 'new/New.xcworkspace', type: 'workspace' }],
-            schemes: ['NewScheme'],
-        });
-        await runBuild(makeOptions({ reselect: true }), deps);
-        assert.strictEqual(savedConfigs.length, 1);
-        assert.strictEqual(savedConfigs[0].project_path, 'new/New.xcworkspace');
-        assert.strictEqual(savedConfigs[0].scheme, 'NewScheme');
-    });
 });

package/dist/commands/build/detect-project.d.ts

@@ -0,0 +1,52 @@
+/**
+ * AI-powered build plan generation.
+ *
+ * Separation of concerns:
+ *   AI  → analyzes repo structure + product context → outputs a BuildPlan (JSON)
+ *   Code → executes the plan deterministically (install deps, find scheme)
+ *
+ * The AI never executes commands. It only reads the directory tree we give it.
+ */
+/** A shell command the build runner should execute. */
+export interface InstallStep {
+    cmd: string;
+    args: string[];
+    /** Working directory relative to repo root. Empty string = repo root. */
+    cwd: string;
+}
+/** The AI's analysis of how to build this repo. */
+export interface BuildPlan {
+    /** Detected project framework */
+    projectType: 'react-native' | 'flutter' | 'expo' | 'native' | 'xcodegen' | 'tuist' | 'spm' | 'other';
+    /** Ordered list of commands to install dependencies / generate projects */
+    installSteps: InstallStep[];
+    /** Expected Xcode project path (relative to repo root) after deps are installed */
+    projectPath: string;
+    /** Hint for the scheme name (may be empty — code will discover via xcodebuild -list) */
+    schemeHint: string;
+    /** Why the AI made these decisions */
+    reasoning: string;
+}
+export interface AnalyzeParams {
+    /** Absolute path to the cloned repository */
+    repoPath: string;
+    /** Product name from the database */
+    productName: string;
+    /** Product description from the database */
+    productDescription?: string;
+}
+/** Injectable for testing */
+export type AnalyzeBuildPlanFn = (params: AnalyzeParams) => Promise<BuildPlan | null>;
+/**
+ * Build a concise directory tree string for the repository.
+ * Only goes `maxDepth` levels deep and skips vendored directories.
+ */
+export declare function buildDirectoryTree(rootDir: string, maxDepth?: number): string;
+/** Validate that the AI only proposed safe, expected commands. */
+export declare function validateInstallSteps(steps: InstallStep[]): InstallStep[];
+export declare function parseBuildPlan(response: string): BuildPlan | null;
+/**
+ * Ask AI to analyze the repo and produce a build plan.
+ * The AI sees only the directory tree — it cannot execute commands.
+ */
+export declare function analyzeBuildPlan(params: AnalyzeParams): Promise<BuildPlan | null>;

package/dist/commands/build/detect-project.js

@@ -0,0 +1,277 @@
+/**
+ * AI-powered build plan generation.
+ *
+ * Separation of concerns:
+ *   AI  → analyzes repo structure + product context → outputs a BuildPlan (JSON)
+ *   Code → executes the plan deterministically (install deps, find scheme)
+ *
+ * The AI never executes commands. It only reads the directory tree we give it.
+ */
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logInfo, logWarning } from '../../utils/logger.js';
+// ── Directory tree helper ──────────────────────────────────────────
+const SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'Pods',
+    'DerivedData',
+    'build',
+    '.build',
+    'Carthage',
+    '.next',
+    '.expo',
+]);
+/**
+ * Build a concise directory tree string for the repository.
+ * Only goes `maxDepth` levels deep and skips vendored directories.
+ */
+export function buildDirectoryTree(rootDir, maxDepth = 3) {
+    const lines = [];
+    function walk(dir, prefix, depth) {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir).sort();
+        }
+        catch {
+            return;
+        }
+        const filtered = entries.filter((e) => {
+            if (SKIP_DIRS.has(e))
+                return false;
+            if (depth > 0 &&
+                e.startsWith('.') &&
+                !e.endsWith('.xcworkspace') &&
+                !e.endsWith('.xcodeproj'))
+                return false;
+            return true;
+        });
+        for (let i = 0; i < filtered.length; i++) {
+            const entry = filtered[i];
+            const fullPath = join(dir, entry);
+            const isLast = i === filtered.length - 1;
+            const connector = isLast ? '└── ' : '├── ';
+            const childPrefix = isLast ? '    ' : '│   ';
+            let isDir = false;
+            try {
+                isDir = statSync(fullPath).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            lines.push(`${prefix}${connector}${entry}${isDir ? '/' : ''}`);
+            if (isDir) {
+                walk(fullPath, prefix + childPrefix, depth + 1);
+            }
+        }
+    }
+    walk(rootDir, '', 0);
+    return lines.join('\n');
+}
+// ── Allowed commands whitelist ─────────────────────────────────────
+const ALLOWED_COMMANDS = new Set([
+    'npm',
+    'yarn',
+    'pnpm',
+    'bun',
+    'pod',
+    'flutter',
+    'xcodegen',
+    'tuist',
+    'swift',
+    'bundle', // ruby bundler (for `bundle exec pod install`)
+]);
+/** Validate that the AI only proposed safe, expected commands. */
+export function validateInstallSteps(steps) {
+    return steps.filter((step) => {
+        if (!ALLOWED_COMMANDS.has(step.cmd)) {
+            logWarning(`Skipping disallowed command: ${step.cmd}`);
+            return false;
+        }
+        return true;
+    });
+}
+// ── Response parser ────────────────────────────────────────────────
+function extractTextFromContent(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+content) {
+    let text = '';
+    for (const item of content) {
+        if (item.type === 'text') {
+            text += item.text;
+        }
+    }
+    return text;
+}
+export function parseBuildPlan(response) {
+    try {
+        const jsonMatch = response.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+        const jsonStr = jsonMatch ? jsonMatch[1] : response;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let parsed;
+        try {
+            parsed = JSON.parse(jsonStr);
+        }
+        catch {
+            const objMatch = jsonStr.match(/\{[\s\S]*"project_path"[\s\S]*"project_type"[\s\S]*\}/);
+            if (objMatch) {
+                parsed = JSON.parse(objMatch[0]);
+            }
+            else {
+                throw new Error('No valid JSON found');
+            }
+        }
+        const plan = parsed.build_plan || parsed;
+        const projectPath = String(plan.project_path || '');
+        if (!projectPath)
+            return null;
+        const installSteps = Array.isArray(plan.install_steps)
+            ? plan.install_steps.map(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (s) => ({
+                cmd: String(s.cmd || ''),
+                args: Array.isArray(s.args) ? s.args.map(String) : [],
+                cwd: String(s.cwd || ''),
+            }))
+            : [];
+        return {
+            projectType: plan.project_type || 'other',
+            installSteps: validateInstallSteps(installSteps),
+            projectPath,
+            schemeHint: String(plan.scheme_hint || ''),
+            reasoning: String(plan.reasoning || ''),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// ── System prompt ──────────────────────────────────────────────────
+const SYSTEM_PROMPT = `You are an expert iOS/macOS build engineer. You are given a repository directory tree and product context. Your ONLY job is to analyze the structure and output a build plan as JSON.
+
+You must NOT execute any commands. You only analyze the directory tree provided and return a plan.
+
+Determine:
+1. **project_type**: What kind of project is this?
+   - "react-native": has package.json with react-native dependency, ios/ directory
+   - "expo": has package.json with expo, app.json/app.config.js
+   - "flutter": has pubspec.yaml, ios/ directory
+   - "xcodegen": has project.yml (XcodeGen config)
+   - "tuist": has Project.swift or Tuist/ directory
+   - "spm": has Package.swift, no .xcodeproj
+   - "native": has .xcodeproj or .xcworkspace already committed
+   - "other": none of the above
+
+2. **install_steps**: Ordered commands needed before building. Each step has:
+   - "cmd": the executable (npm, yarn, pnpm, bun, pod, flutter, xcodegen, tuist, swift, bundle)
+   - "args": array of arguments
+   - "cwd": working directory relative to repo root ("" for repo root, "ios" for ios/ subdirectory)
+
+   Common patterns:
+   - React Native: [npm ci] then [pod install in ios/]
+   - React Native with yarn.lock: [yarn install --frozen-lockfile] then [pod install in ios/]
+   - Flutter: [flutter pub get] then [pod install in ios/]
+   - xcodegen: [xcodegen generate]
+   - tuist: [tuist generate]
+   - Native with Podfile: [pod install in directory containing Podfile]
+   - Native with Gemfile: [bundle install] then [bundle exec pod install]
+   - Native without deps: [] (empty)
+
+3. **project_path**: The Xcode project to build (relative to repo root).
+   - After pod install, prefer .xcworkspace over .xcodeproj
+   - For React Native: typically "ios/<AppName>.xcworkspace"
+   - For native: wherever the .xcworkspace/.xcodeproj is
+
+4. **scheme_hint**: Best guess for the scheme name. Often matches the app name.
+   Leave empty "" if unsure — the build system will discover it via xcodebuild -list.
+
+5. **reasoning**: Brief explanation of your analysis.
+
+In monorepos with multiple apps, use the product name/description to pick the right one.
+
+Respond with ONLY a JSON block, no other text:`;
+// ── Main AI call ───────────────────────────────────────────────────
+/**
+ * Ask AI to analyze the repo and produce a build plan.
+ * The AI sees only the directory tree — it cannot execute commands.
+ */
+export async function analyzeBuildPlan(params) {
+    const { repoPath, productName, productDescription } = params;
+    const tree = buildDirectoryTree(repoPath);
+    const prompt = `Analyze this repository and produce a build plan.
+
+**Product name:** ${productName}
+**Product description:** ${productDescription || 'N/A'}
+
+**Repository structure:**
+\`\`\`
+${tree}
+\`\`\`
+
+\`\`\`json
+{
+  "build_plan": {
+    "project_type": "<react-native|flutter|expo|native|xcodegen|tuist|spm|other>",
+    "install_steps": [
+      { "cmd": "<executable>", "args": ["<arg1>", "<arg2>"], "cwd": "<relative dir or empty>" }
+    ],
+    "project_path": "<relative path to .xcworkspace or .xcodeproj>",
+    "scheme_hint": "<scheme name or empty>",
+    "reasoning": "<brief explanation>"
+  }
+}
+\`\`\``;
+    logInfo('Analyzing repository with AI...');
+    let resultText = '';
+    try {
+        for await (const message of query({
+            prompt,
+            options: {
+                systemPrompt: SYSTEM_PROMPT,
+                model: DEFAULT_MODEL,
+                maxTurns: 1,
+            },
+        })) {
+            if (message.type === 'assistant') {
+                resultText += extractTextFromContent(message.message?.content ?? []);
+                continue;
+            }
+            if (message.type === 'result') {
+                if (message.subtype === 'success' && message.result) {
+                    resultText = message.result;
+                }
+            }
+        }
+        const plan = parseBuildPlan(resultText);
+        if (plan) {
+            logInfo(`AI analysis complete:`);
+            logInfo(`  Type:    ${plan.projectType}`);
+            logInfo(`  Project: ${plan.projectPath}`);
+            if (plan.schemeHint) {
+                logInfo(`  Scheme:  ${plan.schemeHint}`);
+            }
+            if (plan.installSteps.length > 0) {
+                logInfo(`  Install steps:`);
+                for (const step of plan.installSteps) {
+                    const cwdSuffix = step.cwd ? ` (in ${step.cwd}/)` : '';
+                    logInfo(`    - ${step.cmd} ${step.args.join(' ')}${cwdSuffix}`);
+                }
+            }
+            if (plan.reasoning) {
+                logInfo(`  Reasoning: ${plan.reasoning}`);
+            }
+        }
+        else {
+            logWarning('AI did not return a valid build plan');
+        }
+        return plan;
+    }
+    catch (error) {
+        logWarning(`AI analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}

package/dist/commands/build/index.d.ts

@@ -1,5 +1,7 @@
 import { type AppStoreConfig, type BuildConfig } from '../../api/app-store.js';
+import { type ProductInfo } from '../../api/products.js';
 import { type CliOptions } from '../../types/index.js';
+import { type AnalyzeBuildPlanFn } from './detect-project.js';
 export interface BuildOptions extends CliOptions {
     buildProductId: string;
     scheme?: string;
@@ -22,6 +24,7 @@ export type Platform = 'ios' | 'macos';
  */
 export interface BuildDeps {
     fetchConfigs: (productId: string, verbose?: boolean) => Promise<AppStoreConfig[]>;
+    fetchProduct: (productId: string, verbose?: boolean) => Promise<ProductInfo>;
     fetchGitHub: (productId: string, verbose?: boolean) => Promise<{
         configured: boolean;
         token?: string;
@@ -35,7 +38,11 @@ export interface BuildDeps {
     getWorkspaceRoot: () => string;
     saveBuildConfig: (configId: string, buildConfig: BuildConfig, verbose?: boolean) => Promise<AppStoreConfig | null>;
     checkoutDefaultBranch: (repoPath: string) => void;
+    /** AI analysis: read repo structure → output a BuildPlan (no execution) */
+    analyzeBuildPlan: AnalyzeBuildPlanFn;
+    /** Scan for .xcworkspace / .xcodeproj files */
     findProjects: (rootDir: string) => XcodeProject[];
+    /** Manual fallback: run xcodebuild -list to discover schemes */
     findSchemes: (repoPath: string, projectPath: string, projectType: 'workspace' | 'project') => string[];
     runCommand: (cmd: string, args: string[], opts?: {
         cwd?: string;

package/dist/commands/build/index.js

@@ -1,20 +1,24 @@
 import { execFileSync, execSync, spawn } from 'child_process';
 import { existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync, } from 'fs';
 import { homedir } from 'os';
-import { dirname, join, relative } from 'path';
+import { join, relative } from 'path';
 import { getAppStoreConfigs, updateBuildConfig, } from '../../api/app-store.js';
 import { getGitHubConfigByProduct } from '../../api/github.js';
+import { getProduct } from '../../api/products.js';
 import { logInfo, logSuccess, logWarning } from '../../utils/logger.js';
 import { cloneFeatureRepo, ensureWorkspaceDir, } from '../../workspace/workspace-manager.js';
+import { analyzeBuildPlan, } from './detect-project.js';
 /** Default (real) implementations of all dependencies. */
 export function createDefaultDeps() {
     return {
         fetchConfigs: getAppStoreConfigs,
+        fetchProduct: getProduct,
         fetchGitHub: getGitHubConfigByProduct,
         cloneRepo: (workspaceRoot, dirName, owner, repo, token) => cloneFeatureRepo(workspaceRoot, dirName, owner, repo, token),
         getWorkspaceRoot: ensureWorkspaceDir,
         saveBuildConfig: updateBuildConfig,
         checkoutDefaultBranch: checkoutDefaultBranchImpl,
+        analyzeBuildPlan: analyzeBuildPlan,
         findProjects: findXcodeProjects,
         findSchemes: discoverSchemes,
         runCommand: spawnAsync,
@@ -289,28 +293,80 @@ export async function runBuild(options, deps = createDefaultDeps()) {
         const workspaceRoot = deps.getWorkspaceRoot();
         const { repoPath } = deps.cloneRepo(workspaceRoot, `build-${productId}`, github.owner, github.repo, github.token);
         deps.checkoutDefaultBranch(repoPath);
-        // 4. Resolve Xcode project path
-        let projectPath = options.project || buildConfig.project_path;
+        // 4. Resolve project path, scheme, and install dependencies.
+        //    If we already have a saved build_config (and not --reselect),
+        //    skip the AI and use the saved values directly.
+        //    Otherwise: AI analyzes → code executes install steps → discover project/scheme.
+        let projectPath = options.project || (shouldReselect ? undefined : buildConfig.project_path);
         let projectType = 'workspace';
-        if (!projectPath || shouldReselect) {
-            const projects = deps.findProjects(repoPath);
-            if (projects.length === 0) {
-                throw new Error(`No Xcode projects found in ${repoPath}.\n` +
-                    'Ensure the repository contains a .xcworkspace or .xcodeproj file.');
+        let scheme = options.scheme || (shouldReselect ? undefined : buildConfig.scheme);
+        const needsDiscovery = !projectPath || !scheme || shouldReselect;
+        if (needsDiscovery) {
+            // 4a. Ask AI to analyze the repo and produce a build plan
+            const product = await deps.fetchProduct(productId, verbose);
+            const plan = await deps.analyzeBuildPlan({
+                repoPath,
+                productName: product.name,
+                productDescription: product.description,
+            });
+            // 4b. Execute the plan's install steps (deterministic)
+            if (plan) {
+                for (const step of plan.installSteps) {
+                    const cwd = step.cwd ? join(repoPath, step.cwd) : repoPath;
+                    logInfo(`Running: ${step.cmd} ${step.args.join(' ')}${step.cwd ? ` (in ${step.cwd}/)` : ''}`);
+                    try {
+                        await deps.runCommand(step.cmd, step.args, {
+                            cwd,
+                            timeout: 300_000,
+                        });
+                        logSuccess(`${step.cmd} completed`);
+                    }
+                    catch {
+                        logWarning(`${step.cmd} ${step.args[0] || ''} failed — continuing`);
+                    }
+                }
             }
-            if (projects.length === 1) {
-                projectPath = projects[0].path;
-                projectType = projects[0].type;
-                logInfo(`Found Xcode project: ${projectPath}`);
+            // 4c. Resolve project path — prefer AI hint, fallback to scan
+            if (!projectPath) {
+                if (plan?.projectPath) {
+                    const fullPath = join(repoPath, plan.projectPath);
+                    if (existsSync(fullPath)) {
+                        projectPath = plan.projectPath;
+                        logInfo(`Using AI-suggested project: ${projectPath}`);
+                    }
+                    else {
+                        logWarning(`AI-suggested project not found: ${plan.projectPath}`);
+                    }
+                }
+                // Fallback: scan filesystem
+                if (!projectPath) {
+                    const projects = deps.findProjects(repoPath);
+                    if (projects.length === 0) {
+                        throw new Error(`No Xcode projects found in ${repoPath}.\n` +
+                            'Ensure the repository contains a .xcworkspace or .xcodeproj file.');
+                    }
+                    projectPath = projects[0].path;
+                    projectType = projects[0].type;
+                    logInfo(`Found project: ${projectPath}`);
+                }
             }
-            else {
-                logInfo(`Found ${projects.length} Xcode projects:`);
-                for (let i = 0; i < projects.length; i++) {
-                    logInfo(`  [${i + 1}] ${projects[i].path} (${projects[i].type})`);
+            projectType = projectPath.endsWith('.xcworkspace')
+                ? 'workspace'
+                : 'project';
+            // 4d. Resolve scheme — prefer CLI flag, then AI hint, then xcodebuild -list
+            if (!scheme) {
+                if (plan?.schemeHint) {
+                    scheme = plan.schemeHint;
+                    logInfo(`Using AI-suggested scheme: ${scheme}`);
+                }
+                else {
+                    const schemes = deps.findSchemes(repoPath, projectPath, projectType);
+                    if (schemes.length === 0) {
+                        throw new Error(`No schemes found in ${projectPath}. Specify one with --scheme.`);
+                    }
+                    scheme = schemes[0];
+                    logInfo(`Discovered scheme: ${scheme}`);
                 }
-                projectPath = projects[0].path;
-                projectType = projects[0].type;
-                logInfo(`Auto-selected: ${projectPath}`);
             }
         }
         else {
@@ -318,29 +374,17 @@ export async function runBuild(options, deps = createDefaultDeps()) {
                 ? 'workspace'
                 : 'project';
         }
-        // 5. Resolve scheme
-        let scheme = options.scheme || buildConfig.scheme;
-        if (!scheme || shouldReselect) {
-            const schemes = deps.findSchemes(repoPath, projectPath, projectType);
-            if (schemes.length === 0) {
-                throw new Error(`No schemes found in ${projectPath}. Specify one with --scheme.`);
-            }
-            if (schemes.length === 1) {
-                scheme = schemes[0];
-                logInfo(`Using scheme: ${scheme}`);
-            }
-            else {
-                logInfo(`Found schemes: ${schemes.join(', ')}`);
-                scheme = schemes[0];
-                logInfo(`Auto-selected scheme: ${scheme}`);
-            }
+        // At this point projectPath and scheme must be resolved
+        if (!projectPath || !scheme) {
+            throw new Error('Could not determine Xcode project path and scheme.\n' +
+                'Specify them manually with --project and --scheme, or check the repository structure.');
         }
-        // 6. Build settings
+        // 5. Build settings
         const configuration = options.configuration || buildConfig.configuration || 'Release';
         const teamId = buildConfig.team_id;
         const exportMethod = buildConfig.export_method || 'app-store';
         const platform = options.platform || 'ios';
-        // 7. Persist discovered build config
+        // 6. Persist discovered build config to DB
         const newBuildConfig = {
             project_path: projectPath,
             scheme,
@@ -354,31 +398,8 @@ export async function runBuild(options, deps = createDefaultDeps()) {
             logInfo('Saving build configuration...');
             await deps.saveBuildConfig(appleConfig.id, newBuildConfig, verbose);
         }
-        // 8. Install dependencies (CocoaPods)
-        const projectDir = projectPath.includes('/')
-            ? join(repoPath, dirname(projectPath))
-            : repoPath;
-        for (const podfile of [
-            join(projectDir, 'Podfile'),
-            join(repoPath, 'Podfile'),
-        ]) {
-            if (existsSync(podfile)) {
-                logInfo('Installing CocoaPods dependencies...');
-                try {
-                    await deps.runCommand('pod', ['install'], {
-                        cwd: dirname(podfile),
-                        timeout: 300_000,
-                    });
-                    logSuccess('CocoaPods installed');
-                }
-                catch {
-                    logWarning('pod install failed — continuing anyway');
-                }
-                break;
-            }
-        }
         if (!options.skipArchive && !options.ipa) {
-            // 9. Archive (async, cancellable)
+            // 7. Archive (async, cancellable)
             const archivePath = join(repoPath, 'build', `${scheme}.xcarchive`);
             const projectFlag = projectType === 'workspace' ? '-workspace' : '-project';
             const fullProjectPath = join(repoPath, projectPath);
@@ -405,7 +426,7 @@ export async function runBuild(options, deps = createDefaultDeps()) {
                 timeout: 1_200_000,
             });
             logSuccess('Archive created successfully');
-            // 10. Export IPA / .app
+            // 8. Export IPA / .app
             if (!teamId) {
                 logWarning('team_id not configured — skipping export. Set it in build settings.');
                 return;

package/dist/phases/app-store-generation/index.js

@@ -7,6 +7,12 @@ import { prepareAppStoreContext } from './context.js';
 import { createAppStoreSystemPrompt } from './prompts.js';
 import { generateStoreScreenshots, } from './screenshot-composer.js';
 import { uploadAppStoreScreenshots } from './uploader.js';
+function truncateKeywords(keywords) {
+    if (keywords.length <= 100) {
+        return keywords;
+    }
+    return keywords.slice(0, 100).replace(/,[^,]*$/, '');
+}
 export const generateAppStoreAssets = async (options, config
 // eslint-disable-next-line complexity -- orchestration function with sequential asset generation steps
 ) => {
@@ -66,9 +72,7 @@ export const generateAppStoreAssets = async (options, config
                 short_description: listing.short_description?.slice(0, 80),
                 description: listing.description?.slice(0, 4000) ?? '',
                 keywords: listing.keywords
-                    ? listing.keywords.length > 100
-                        ? listing.keywords.slice(0, 100).replace(/,[^,]*$/, '')
-                        : listing.keywords
+                    ? truncateKeywords(listing.keywords)
                     : undefined,
             };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.36.0",
+  "version": "0.36.2",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"