edsger 0.46.0 → 0.47.0

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

@@ -0,0 +1,433 @@
+/**
+ * Integration tests for the runBuild orchestration function.
+ * Uses dependency injection (BuildDeps) to mock external calls
+ * while testing the full decision-making pipeline.
+ */
+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 { runBuild } from '../index.js';
+// ── Helpers ────────────────────────────────────────────────────────
+function createTmpDir() {
+    const dir = join(tmpdir(), `edsger-run-build-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+function makeAppleConfig(overrides = {}) {
+    return {
+        id: 'config-1',
+        product_id: 'prod-1',
+        store_type: 'apple_app_store',
+        credentials: {
+            key_id: 'KEY123',
+            issuer_id: 'ISSUER456',
+            private_key: '-----BEGIN PRIVATE KEY-----\ntest\n-----END PRIVATE KEY-----',
+        },
+        app_identifier: 'com.example.app',
+        listings: {},
+        screenshots: {},
+        build_config: {},
+        current_version: null,
+        submission_status: 'none',
+        submitted_at: null,
+        released_at: null,
+        rejection_reason: null,
+        is_active: true,
+        created_by: 'user-1',
+        created_at: '2024-01-01',
+        updated_at: '2024-01-01',
+        ...overrides,
+    };
+}
+function makeOptions(overrides = {}) {
+    return {
+        buildProductId: 'prod-1',
+        verbose: false,
+        ...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 = [];
+    const tmpDir = overrides.tmpDir ?? createTmpDir();
+    // Create a fake .ipa in the export directory so the build flow completes
+    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,
+                token: 'ghp_test',
+                owner: 'org',
+                repo: 'app',
+            })),
+        cloneRepo: overrides.cloneRepo ?? (() => ({ repoPath: tmpDir })),
+        getWorkspaceRoot: overrides.getWorkspaceRoot ?? (() => tmpDir),
+        saveBuildConfig: overrides.saveBuildConfig ??
+            (async (_id, bc) => {
+                savedConfigs.push(bc);
+                return null;
+            }),
+        checkoutDefaultBranch: overrides.checkoutDefaultBranch ?? (() => { }),
+        analyzeBuildPlan: overrides.analyzeBuildPlan ?? (async () => DEFAULT_PLAN),
+        findProjects: overrides.findProjects ??
+            (() => overrides.projects ?? [
+                { path: 'ios/MyApp.xcworkspace', type: 'workspace' },
+            ]),
+        findSchemes: overrides.findSchemes ?? (() => overrides.schemes ?? ['MyApp']),
+        runCommand: overrides.runCommand ??
+            (async (cmd, args, opts) => {
+                calls.push({ cmd, args, opts });
+            }),
+        isXcodeAvailable: overrides.isXcodeAvailable ?? (() => true),
+    };
+    return { deps, calls, savedConfigs };
+}
+// ── Tests ──────────────────────────────────────────────────────────
+describe('runBuild orchestration', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = createTmpDir();
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    // -- Error paths --
+    it('throws when xcodebuild is not available', async () => {
+        const { deps } = createMockDeps({
+            tmpDir,
+            isXcodeAvailable: () => false,
+        });
+        await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
+            assert.ok(err.message.includes('xcodebuild is not available'));
+            return true;
+        });
+    });
+    it('throws when no Apple App Store config exists', async () => {
+        const { deps } = createMockDeps({
+            tmpDir,
+            configs: [],
+        });
+        await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
+            assert.ok(err.message.includes('No Apple App Store configuration'));
+            return true;
+        });
+    });
+    it('throws when GitHub is not configured', async () => {
+        const { deps } = createMockDeps({
+            tmpDir,
+            fetchGitHub: async () => ({
+                configured: false,
+                message: 'No repo connected',
+            }),
+        });
+        await assert.rejects(() => runBuild(makeOptions(), deps), (err) => {
+            assert.ok(err.message.includes('GitHub not configured'));
+            return true;
+        });
+    });
+    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) => {
+            assert.ok(err.message.includes('No Xcode projects found'));
+            return true;
+        });
+    });
+    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) => {
+            assert.ok(err.message.includes('No schemes found'));
+            return true;
+        });
+    });
+    // -- 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',
+            }),
+        });
+        await runBuild(makeOptions(), deps);
+        // 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 AI-suggested project path and scheme', async () => {
+        mkdirSync(join(tmpDir, 'apps', 'mobile', 'ios', 'Mobile.xcworkspace'), {
+            recursive: true,
+        });
+        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], 'ManualScheme');
+    });
+    // -- 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],
+            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('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, '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: 'ios/MyApp.xcworkspace',
+                scheme: 'MyApp',
+                configuration: 'Release',
+            },
+        });
+        const { deps, savedConfigs } = createMockDeps({
+            tmpDir,
+            configs: [config],
+        });
+        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: {
+                project_path: 'A.xcworkspace',
+                scheme: 'A',
+                configuration: 'Release',
+                team_id: 'TEAM1',
+                export_method: 'app-store',
+            },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        await runBuild(makeOptions({ upload: true }), deps);
+        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'));
+    });
+    it('uses notarytool for macOS platform upload', async () => {
+        const config = makeAppleConfig({
+            build_config: {
+                project_path: 'A.xcworkspace',
+                scheme: 'A',
+                configuration: 'Release',
+                team_id: 'TEAM1',
+                export_method: 'app-store',
+            },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        await runBuild(makeOptions({ upload: true, platform: 'macos' }), deps);
+        const uploadCall = calls.find((c) => c.cmd === 'xcrun' && c.args.includes('notarytool'));
+        assert.ok(uploadCall, 'Expected xcrun notarytool call for macOS');
+    });
+    it('passes platform destination to xcodebuild', async () => {
+        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('skips archive when --skipArchive is set', async () => {
+        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);
+    });
+    it('adds DEVELOPMENT_TEAM when team_id is set', async () => {
+        const config = makeAppleConfig({
+            build_config: {
+                project_path: 'A.xcworkspace',
+                scheme: 'A',
+                configuration: 'Release',
+                team_id: 'TEAM123',
+            },
+        });
+        const { deps, calls } = createMockDeps({ tmpDir, configs: [config] });
+        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 === 'DEVELOPMENT_TEAM=TEAM123'));
+    });
+});

package/dist/commands/intelligence/__tests__/command.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Unit tests for intelligence command display helpers.
+ */
+export {};

package/dist/commands/intelligence/__tests__/command.test.js

@@ -0,0 +1,48 @@
+/**
+ * Unit tests for intelligence command display helpers.
+ */
+import assert from 'node:assert';
+import { describe, it } from 'node:test';
+// ============================================================
+// IntelCommandOptions type validation
+// ============================================================
+void describe('IntelCommandOptions', () => {
+    void it('should accept minimal options', () => {
+        const opts = { productId: 'prod-001' };
+        assert.strictEqual(opts.productId, 'prod-001');
+        assert.strictEqual(opts.reportType, undefined);
+        assert.strictEqual(opts.verbose, undefined);
+    });
+    void it('should accept full options', () => {
+        const opts = {
+            productId: 'prod-001',
+            reportType: 'competitive',
+            verbose: true,
+            guidance: 'Focus on pricing',
+            reportId: 'report-1',
+            listCompetitors: false,
+            confirmCompetitor: undefined,
+            dismissCompetitor: undefined,
+        };
+        assert.strictEqual(opts.productId, 'prod-001');
+        assert.strictEqual(opts.reportType, 'competitive');
+        assert.strictEqual(opts.guidance, 'Focus on pricing');
+    });
+    void it('should accept competitor management options', () => {
+        const listOpts = {
+            productId: 'prod-001',
+            listCompetitors: true,
+        };
+        assert.strictEqual(listOpts.listCompetitors, true);
+        const confirmOpts = {
+            productId: 'prod-001',
+            confirmCompetitor: 'comp-123',
+        };
+        assert.strictEqual(confirmOpts.confirmCompetitor, 'comp-123');
+        const dismissOpts = {
+            productId: 'prod-001',
+            dismissCompetitor: 'comp-456',
+        };
+        assert.strictEqual(dismissOpts.dismissCompetitor, 'comp-456');
+    });
+});

package/dist/commands/run-sheet/index.js

@@ -24,12 +24,18 @@ export const runRunSheetCommand = async (options) => {
         if (result.status === 'cached') {
             logInfo(`Run sheet unchanged for ${result.releaseTag} — skipped clone.`);
         }
+        else if (result.isDraft) {
+            logInfo(`Generated DRAFT run sheet for ${result.releaseTag} (tag not yet cut; used default branch).`);
+        }
         else {
             logInfo(`Generated run sheet for ${result.releaseTag}`);
         }
         if (result.cloneError) {
             logInfo(`Clone warning: ${result.cloneError}`);
         }
+        if (result.commitsError) {
+            logInfo(`Commits warning: could not fetch commit list (${result.commitsError}). Run sheet rendered without {{commits}} / {{#each commits}} content.`);
+        }
         if (result.missingPlaceholders && result.missingPlaceholders.length > 0) {
             logInfo(`Unresolved placeholders: ${result.missingPlaceholders.join(', ')}`);
         }

package/dist/commands/workflow/core/__tests__/feature-filter.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Unit tests for feature-filter module
+ * Pure functions for filtering and selecting features for processing
+ */
+export {};