ios-app-review-plugin 1.0.0

package/tests/parsers/plist.test.ts

@@ -0,0 +1,240 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { parsePlist, fileExists, readFile, parsePbxproj } from '../../src/parsers/plist.js';
+
+describe('plist parser', () => {
+  let tempDir: string;
+
+  beforeAll(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'plist-test-'));
+  });
+
+  afterAll(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('parsePlist', () => {
+    it('should parse a valid XML plist file', async () => {
+      const plistPath = path.join(tempDir, 'valid.plist');
+      await fs.writeFile(
+        plistPath,
+        `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleIdentifier</key>
+  <string>com.test.app</string>
+  <key>CFBundleName</key>
+  <string>TestApp</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+</dict>
+</plist>`
+      );
+
+      const result = await parsePlist<Record<string, unknown>>(plistPath);
+
+      expect(result['CFBundleIdentifier']).toBe('com.test.app');
+      expect(result['CFBundleName']).toBe('TestApp');
+      expect(result['CFBundleVersion']).toBe('1');
+    });
+
+    it('should throw for an invalid plist file', async () => {
+      const plistPath = path.join(tempDir, 'invalid.plist');
+      await fs.writeFile(plistPath, 'this is not valid plist content at all <><>');
+
+      await expect(parsePlist(plistPath)).rejects.toThrow();
+    });
+  });
+
+  describe('fileExists', () => {
+    it('should return true for an existing file', async () => {
+      const filePath = path.join(tempDir, 'exists.txt');
+      await fs.writeFile(filePath, 'hello');
+
+      const result = await fileExists(filePath);
+      expect(result).toBe(true);
+    });
+
+    it('should return false for a non-existing file', async () => {
+      const filePath = path.join(tempDir, 'does-not-exist.txt');
+
+      const result = await fileExists(filePath);
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('readFile', () => {
+    it('should read file contents as a string', async () => {
+      const filePath = path.join(tempDir, 'readable.txt');
+      await fs.writeFile(filePath, 'file content here');
+
+      const result = await readFile(filePath);
+      expect(result).toBe('file content here');
+    });
+  });
+
+  describe('parsePbxproj', () => {
+    it('should extract archiveVersion, objectVersion, and rootObject', () => {
+      const content = `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  classes = {};
+  objectVersion = 56;
+  objects = {
+    AAAAAAAAAAAAAAAAAAAAAAAA = { isa = PBXProject; mainGroup = BBBBBBBBBBBBBBBBBBBBBBBB; targets = (); };
+    BBBBBBBBBBBBBBBBBBBBBBBB = { isa = PBXGroup; children = (); sourceTree = "<group>"; };
+  };
+  rootObject = AAAAAAAAAAAAAAAAAAAAAAAA;
+}
+`;
+
+      const result = parsePbxproj(content);
+
+      expect(result.archiveVersion).toBe('1');
+      expect(result.objectVersion).toBe('56');
+      expect(result.rootObject).toBe('AAAAAAAAAAAAAAAAAAAAAAAA');
+    });
+
+    it('should parse objects with various isa types', () => {
+      const content = `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  objectVersion = 56;
+  objects = {
+    AAAAAAAAAAAAAAAAAAAAAAAA = { isa = PBXProject; mainGroup = CCCCCCCCCCCCCCCCCCCCCCCC; targets = (BBBBBBBBBBBBBBBBBBBBBBBB); };
+    BBBBBBBBBBBBBBBBBBBBBBBB = { isa = PBXNativeTarget; name = MyApp; productType = "com.apple.product-type.application"; buildPhases = (); };
+    CCCCCCCCCCCCCCCCCCCCCCCC = { isa = PBXGroup; children = (); sourceTree = "<group>"; };
+    DDDDDDDDDDDDDDDDDDDDDDDD = { isa = PBXFileReference; path = "AppDelegate.swift"; sourceTree = "<group>"; };
+    EEEEEEEEEEEEEEEEEEEEEEEE = { isa = XCBuildConfiguration; name = Debug; buildSettings = { PRODUCT_BUNDLE_IDENTIFIER = "com.test.myapp"; }; };
+  };
+  rootObject = AAAAAAAAAAAAAAAAAAAAAAAA;
+}
+`;
+
+      const result = parsePbxproj(content);
+
+      expect(result.objects['AAAAAAAAAAAAAAAAAAAAAAAA']?.isa).toBe('PBXProject');
+      expect(result.objects['BBBBBBBBBBBBBBBBBBBBBBBB']?.isa).toBe('PBXNativeTarget');
+      expect(result.objects['BBBBBBBBBBBBBBBBBBBBBBBB']?.name).toBe('MyApp');
+      expect(result.objects['BBBBBBBBBBBBBBBBBBBBBBBB']?.productType).toBe(
+        'com.apple.product-type.application'
+      );
+      expect(result.objects['CCCCCCCCCCCCCCCCCCCCCCCC']?.isa).toBe('PBXGroup');
+      expect(result.objects['DDDDDDDDDDDDDDDDDDDDDDDD']?.isa).toBe('PBXFileReference');
+      expect(result.objects['DDDDDDDDDDDDDDDDDDDDDDDD']?.path).toBe('AppDelegate.swift');
+      expect(result.objects['EEEEEEEEEEEEEEEEEEEEEEEE']?.isa).toBe('XCBuildConfiguration');
+    });
+
+    it('should parse buildSettings correctly', () => {
+      const content = `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  objectVersion = 56;
+  objects = {
+    AAAAAAAAAAAAAAAAAAAAAAAA = { isa = XCBuildConfiguration; name = Debug; buildSettings = { PRODUCT_BUNDLE_IDENTIFIER = "com.test.app"; IPHONEOS_DEPLOYMENT_TARGET = "16.0"; INFOPLIST_FILE = "App/Info.plist"; CODE_SIGN_ENTITLEMENTS = "App/App.entitlements"; SWIFT_VERSION = "5.0"; }; };
+    BBBBBBBBBBBBBBBBBBBBBBBB = { isa = PBXProject; mainGroup = CCCCCCCCCCCCCCCCCCCCCCCC; targets = (); };
+    CCCCCCCCCCCCCCCCCCCCCCCC = { isa = PBXGroup; children = (); sourceTree = "<group>"; };
+  };
+  rootObject = BBBBBBBBBBBBBBBBBBBBBBBB;
+}
+`;
+
+      const result = parsePbxproj(content);
+      const config = result.objects['AAAAAAAAAAAAAAAAAAAAAAAA'];
+
+      expect(config?.buildSettings).toBeDefined();
+      expect(config!.buildSettings!['PRODUCT_BUNDLE_IDENTIFIER']).toBe('com.test.app');
+      expect(config!.buildSettings!['IPHONEOS_DEPLOYMENT_TARGET']).toBe('16.0');
+      expect(config!.buildSettings!['INFOPLIST_FILE']).toBe('App/Info.plist');
+      expect(config!.buildSettings!['CODE_SIGN_ENTITLEMENTS']).toBe('App/App.entitlements');
+      expect(config!.buildSettings!['SWIFT_VERSION']).toBe('5.0');
+    });
+
+    it('should parse arrays (files, buildPhases, buildConfigurations)', () => {
+      const content = `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  objectVersion = 56;
+  objects = {
+    AAAAAAAAAAAAAAAAAAAAAAAA = { isa = PBXNativeTarget; name = TestApp; buildPhases = (BBBBBBBBBBBBBBBBBBBBBBBB, CCCCCCCCCCCCCCCCCCCCCCCC); buildConfigurationList = DDDDDDDDDDDDDDDDDDDDDDDD; };
+    BBBBBBBBBBBBBBBBBBBBBBBB = { isa = PBXSourcesBuildPhase; files = (EEEEEEEEEEEEEEEEEEEEEEEE, FFFFFFFFFFFFFFFFFFFFFFFF); };
+    CCCCCCCCCCCCCCCCCCCCCCCC = { isa = PBXFrameworksBuildPhase; files = (); };
+    DDDDDDDDDDDDDDDDDDDDDDDD = { isa = XCConfigurationList; buildConfigurations = (111111111111111111111111, 222222222222222222222222); };
+    EEEEEEEEEEEEEEEEEEEEEEEE = { isa = PBXBuildFile; };
+    FFFFFFFFFFFFFFFFFFFFFFFF = { isa = PBXBuildFile; };
+    111111111111111111111111 = { isa = XCBuildConfiguration; name = Debug; buildSettings = { }; };
+    222222222222222222222222 = { isa = XCBuildConfiguration; name = Release; buildSettings = { }; };
+    333333333333333333333333 = { isa = PBXProject; mainGroup = 444444444444444444444444; targets = (AAAAAAAAAAAAAAAAAAAAAAAA); };
+    444444444444444444444444 = { isa = PBXGroup; children = (); sourceTree = "<group>"; };
+  };
+  rootObject = 333333333333333333333333;
+}
+`;
+
+      const result = parsePbxproj(content);
+
+      // Check buildPhases array
+      const target = result.objects['AAAAAAAAAAAAAAAAAAAAAAAA'];
+      expect(target?.buildPhases).toEqual([
+        'BBBBBBBBBBBBBBBBBBBBBBBB',
+        'CCCCCCCCCCCCCCCCCCCCCCCC',
+      ]);
+
+      // Check files array
+      const sourcesPhase = result.objects['BBBBBBBBBBBBBBBBBBBBBBBB'];
+      expect(sourcesPhase?.files).toEqual([
+        'EEEEEEEEEEEEEEEEEEEEEEEE',
+        'FFFFFFFFFFFFFFFFFFFFFFFF',
+      ]);
+
+      // Check buildConfigurations array
+      const configList = result.objects['DDDDDDDDDDDDDDDDDDDDDDDD'];
+      expect(configList?.['buildConfigurations']).toEqual([
+        '111111111111111111111111',
+        '222222222222222222222222',
+      ]);
+    });
+
+    it('should handle content with comments (/* ... */)', () => {
+      const content = `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  objectVersion = 56;
+  objects = {
+    AAAAAAAAAAAAAAAAAAAAAAAA /* MyApp */ = { isa = PBXNativeTarget; name = MyApp; productType = "com.apple.product-type.application"; buildPhases = (); };
+    BBBBBBBBBBBBBBBBBBBBBBBB /* Project object */ = { isa = PBXProject; mainGroup = CCCCCCCCCCCCCCCCCCCCCCCC; targets = (AAAAAAAAAAAAAAAAAAAAAAAA /* MyApp */); };
+    CCCCCCCCCCCCCCCCCCCCCCCC = { isa = PBXGroup; children = (); sourceTree = "<group>"; };
+  };
+  rootObject = BBBBBBBBBBBBBBBBBBBBBBBB /* Project object */;
+}
+`;
+
+      const result = parsePbxproj(content);
+
+      expect(result.rootObject).toBe('BBBBBBBBBBBBBBBBBBBBBBBB');
+      expect(result.objects['AAAAAAAAAAAAAAAAAAAAAAAA']?.isa).toBe('PBXNativeTarget');
+      expect(result.objects['AAAAAAAAAAAAAAAAAAAAAAAA']?.name).toBe('MyApp');
+    });
+
+    it('should handle empty objects section', () => {
+      const content = `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  objectVersion = 56;
+  objects = {
+  };
+  rootObject = AAAAAAAAAAAAAAAAAAAAAAAA;
+}
+`;
+
+      const result = parsePbxproj(content);
+
+      expect(result.archiveVersion).toBe('1');
+      expect(result.objectVersion).toBe('56');
+      expect(result.rootObject).toBe('AAAAAAAAAAAAAAAAAAAAAAAA');
+      expect(Object.keys(result.objects)).toHaveLength(0);
+    });
+  });
+});

package/tests/parsers/xcodeproj.test.ts

@@ -0,0 +1,289 @@
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import { parseXcodeProject } from '../../src/parsers/xcodeproj.js';
+
+describe('parseXcodeProject', () => {
+  let tempDir: string;
+
+  beforeAll(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'xcodeproj-test-'));
+  });
+
+  afterAll(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  const VALID_PBXPROJ = `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  classes = {};
+  objectVersion = 56;
+  objects = {
+    AAAAAAAAAAAAAAAAAAAAAAAA = { isa = PBXProject; buildConfigurationList = BBBBBBBBBBBBBBBBBBBBBBBB; mainGroup = CCCCCCCCCCCCCCCCCCCCCCCC; targets = (DDDDDDDDDDDDDDDDDDDDDDDD); };
+    BBBBBBBBBBBBBBBBBBBBBBBB = { isa = XCConfigurationList; buildConfigurations = (EEEEEEEEEEEEEEEEEEEEEEEE, FFFFFFFFFFFFFFFFFFFFFFFF); };
+    EEEEEEEEEEEEEEEEEEEEEEEE = { isa = XCBuildConfiguration; name = Debug; buildSettings = { PRODUCT_BUNDLE_IDENTIFIER = "com.test.app"; IPHONEOS_DEPLOYMENT_TARGET = "16.0"; INFOPLIST_FILE = "TestApp/Info.plist"; CODE_SIGN_ENTITLEMENTS = "TestApp/TestApp.entitlements"; }; };
+    FFFFFFFFFFFFFFFFFFFFFFFF = { isa = XCBuildConfiguration; name = Release; buildSettings = { PRODUCT_BUNDLE_IDENTIFIER = "com.test.app"; IPHONEOS_DEPLOYMENT_TARGET = "16.0"; }; };
+    DDDDDDDDDDDDDDDDDDDDDDDD = { isa = PBXNativeTarget; name = TestApp; productType = "com.apple.product-type.application"; buildConfigurationList = BBBBBBBBBBBBBBBBBBBBBBBB; buildPhases = (111111111111111111111111); };
+    CCCCCCCCCCCCCCCCCCCCCCCC = { isa = PBXGroup; children = (); sourceTree = "<group>"; };
+    111111111111111111111111 = { isa = PBXSourcesBuildPhase; files = (222222222222222222222222); };
+    222222222222222222222222 = { isa = PBXBuildFile; fileRef = 333333333333333333333333; };
+    333333333333333333333333 = { isa = PBXFileReference; path = "ViewController.swift"; sourceTree = "<group>"; };
+  };
+  rootObject = AAAAAAAAAAAAAAAAAAAAAAAA;
+}
+`;
+
+  describe('valid .xcodeproj', () => {
+    it('should parse a valid .xcodeproj project', async () => {
+      const xcodeproj = path.join(tempDir, 'TestApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), VALID_PBXPROJ);
+
+      const project = await parseXcodeProject(xcodeproj);
+
+      expect(project.name).toBe('TestApp');
+      expect(project.path).toBe(xcodeproj);
+      expect(project.targets.length).toBeGreaterThan(0);
+      expect(project.configurations.length).toBeGreaterThan(0);
+    });
+
+    it('should extract targets with name, productType, bundleIdentifier, and deploymentTarget', async () => {
+      const xcodeproj = path.join(tempDir, 'TargetApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), VALID_PBXPROJ);
+
+      const project = await parseXcodeProject(xcodeproj);
+
+      const target = project.targets.find((t) => t.name === 'TestApp');
+      expect(target).toBeDefined();
+      expect(target!.name).toBe('TestApp');
+      expect(target!.type).toBe('application');
+      expect(target!.bundleIdentifier).toBe('com.test.app');
+      expect(target!.deploymentTarget).toBe('16.0');
+    });
+
+    it('should extract build configurations', async () => {
+      const xcodeproj = path.join(tempDir, 'ConfigApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), VALID_PBXPROJ);
+
+      const project = await parseXcodeProject(xcodeproj);
+
+      expect(project.configurations).toContain('Debug');
+      expect(project.configurations).toContain('Release');
+    });
+  });
+
+  describe('invalid project path', () => {
+    it('should throw for a path that is not .xcodeproj or .xcworkspace', async () => {
+      const invalidDir = path.join(tempDir, 'NotAProject');
+      await fs.mkdir(invalidDir, { recursive: true });
+
+      await expect(parseXcodeProject(invalidDir)).rejects.toThrow(
+        'Invalid project path'
+      );
+    });
+
+    it('should throw if project.pbxproj is missing', async () => {
+      const xcodeproj = path.join(tempDir, 'EmptyProj.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+
+      await expect(parseXcodeProject(xcodeproj)).rejects.toThrow(
+        'project.pbxproj not found'
+      );
+    });
+  });
+
+  describe('.xcworkspace parsing', () => {
+    it('should parse a .xcworkspace that references a .xcodeproj', async () => {
+      // Create the workspace directory
+      const workspace = path.join(tempDir, 'WorkspaceApp.xcworkspace');
+      await fs.mkdir(workspace, { recursive: true });
+
+      // Create the referenced xcodeproj inside tempDir
+      const xcodeproj = path.join(tempDir, 'WorkspaceApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), VALID_PBXPROJ);
+
+      // Write workspace data referencing the xcodeproj
+      await fs.writeFile(
+        path.join(workspace, 'contents.xcworkspacedata'),
+        `<?xml version="1.0" encoding="UTF-8"?>
+<Workspace version="1.0">
+  <FileRef location="group:WorkspaceApp.xcodeproj"></FileRef>
+</Workspace>`
+      );
+
+      const project = await parseXcodeProject(workspace);
+
+      expect(project.name).toBe('WorkspaceApp');
+      expect(project.path).toBe(workspace);
+      expect(project.targets.length).toBeGreaterThan(0);
+    });
+
+    it('should throw for an empty .xcworkspace with no project refs', async () => {
+      const workspace = path.join(tempDir, 'EmptyWorkspace.xcworkspace');
+      await fs.mkdir(workspace, { recursive: true });
+
+      await fs.writeFile(
+        path.join(workspace, 'contents.xcworkspacedata'),
+        `<?xml version="1.0" encoding="UTF-8"?>
+<Workspace version="1.0">
+</Workspace>`
+      );
+
+      await expect(parseXcodeProject(workspace)).rejects.toThrow(
+        'No projects found in workspace'
+      );
+    });
+
+    it('should throw if contents.xcworkspacedata is missing', async () => {
+      const workspace = path.join(tempDir, 'NoContents.xcworkspace');
+      await fs.mkdir(workspace, { recursive: true });
+
+      await expect(parseXcodeProject(workspace)).rejects.toThrow(
+        'contents.xcworkspacedata not found'
+      );
+    });
+  });
+
+  describe('source files in build phases', () => {
+    it('should extract source files from PBXSourcesBuildPhase referencing PBXFileReference', async () => {
+      // The pbxproj parser extracts fileRef by matching the pattern inside PBXBuildFile objects.
+      // We need to use a multi-line format where fileRef appears as a parseable key with a 24-char hex ID.
+      const pbxprojWithSourceFiles = `// !$*UTF8*$!
+{
+  archiveVersion = 1;
+  classes = {};
+  objectVersion = 56;
+  objects = {
+    AAAAAAAAAAAAAAAAAAAAAAAA = {
+      isa = PBXProject;
+      buildConfigurationList = BBBBBBBBBBBBBBBBBBBBBBBB;
+      mainGroup = CCCCCCCCCCCCCCCCCCCCCCCC;
+      targets = (DDDDDDDDDDDDDDDDDDDDDDDD);
+    };
+    BBBBBBBBBBBBBBBBBBBBBBBB = {
+      isa = XCConfigurationList;
+      buildConfigurations = (EEEEEEEEEEEEEEEEEEEEEEEE);
+    };
+    EEEEEEEEEEEEEEEEEEEEEEEE = {
+      isa = XCBuildConfiguration;
+      name = Debug;
+      buildSettings = {
+        PRODUCT_BUNDLE_IDENTIFIER = "com.test.app";
+      };
+    };
+    DDDDDDDDDDDDDDDDDDDDDDDD = {
+      isa = PBXNativeTarget;
+      name = TestApp;
+      productType = "com.apple.product-type.application";
+      buildConfigurationList = BBBBBBBBBBBBBBBBBBBBBBBB;
+      buildPhases = (111111111111111111111111);
+    };
+    CCCCCCCCCCCCCCCCCCCCCCCC = {
+      isa = PBXGroup;
+      children = ();
+      sourceTree = "<group>";
+    };
+    111111111111111111111111 = {
+      isa = PBXSourcesBuildPhase;
+      files = (222222222222222222222222);
+    };
+    222222222222222222222222 = {
+      isa = PBXBuildFile;
+      fileRef = 333333333333333333333333;
+    };
+    333333333333333333333333 = {
+      isa = PBXFileReference;
+      path = "ViewController.swift";
+      sourceTree = "<group>";
+    };
+  };
+  rootObject = AAAAAAAAAAAAAAAAAAAAAAAA;
+}
+`;
+      const xcodeproj = path.join(tempDir, 'SourceFilesApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), pbxprojWithSourceFiles);
+
+      const project = await parseXcodeProject(xcodeproj);
+
+      const target = project.targets.find((t) => t.name === 'TestApp');
+      expect(target).toBeDefined();
+      // sourceFiles is populated when the parser can resolve fileRef through PBXBuildFile objects
+      expect(target!.sourceFiles).toBeDefined();
+      expect(Array.isArray(target!.sourceFiles)).toBe(true);
+    });
+  });
+
+  describe('entitlements path in build settings', () => {
+    it('should extract entitlementsPath from CODE_SIGN_ENTITLEMENTS', async () => {
+      const xcodeproj = path.join(tempDir, 'EntApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), VALID_PBXPROJ);
+
+      const project = await parseXcodeProject(xcodeproj);
+
+      const target = project.targets.find((t) => t.name === 'TestApp');
+      expect(target).toBeDefined();
+      expect(target!.entitlementsPath).toBeDefined();
+      expect(target!.entitlementsPath).toContain('TestApp.entitlements');
+    });
+  });
+
+  describe('product type mapping', () => {
+    it('should map com.apple.product-type.application to application', async () => {
+      const xcodeproj = path.join(tempDir, 'AppTypeApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), VALID_PBXPROJ);
+
+      const project = await parseXcodeProject(xcodeproj);
+      const target = project.targets.find((t) => t.name === 'TestApp');
+      expect(target!.type).toBe('application');
+    });
+
+    it('should map com.apple.product-type.framework to framework', async () => {
+      const pbxproj = VALID_PBXPROJ.replace(
+        'com.apple.product-type.application',
+        'com.apple.product-type.framework'
+      );
+      const xcodeproj = path.join(tempDir, 'FrameworkApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), pbxproj);
+
+      const project = await parseXcodeProject(xcodeproj);
+      const target = project.targets.find((t) => t.name === 'TestApp');
+      expect(target!.type).toBe('framework');
+    });
+
+    it('should map com.apple.product-type.library.static to staticLibrary', async () => {
+      const pbxproj = VALID_PBXPROJ.replace(
+        'com.apple.product-type.application',
+        'com.apple.product-type.library.static'
+      );
+      const xcodeproj = path.join(tempDir, 'StaticLibApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), pbxproj);
+
+      const project = await parseXcodeProject(xcodeproj);
+      const target = project.targets.find((t) => t.name === 'TestApp');
+      expect(target!.type).toBe('staticLibrary');
+    });
+
+    it('should map unknown product types to unknown', async () => {
+      const pbxproj = VALID_PBXPROJ.replace(
+        'com.apple.product-type.application',
+        'com.apple.product-type.something-new'
+      );
+      const xcodeproj = path.join(tempDir, 'UnknownTypeApp.xcodeproj');
+      await fs.mkdir(xcodeproj, { recursive: true });
+      await fs.writeFile(path.join(xcodeproj, 'project.pbxproj'), pbxproj);
+
+      const project = await parseXcodeProject(xcodeproj);
+      const target = project.targets.find((t) => t.name === 'TestApp');
+      expect(target!.type).toBe('unknown');
+    });
+  });
+});

package/tests/progress/reporter.test.ts

@@ -0,0 +1,117 @@
+import { ProgressReporter } from '../../src/progress/reporter.js';
+import type { ProgressEvent } from '../../src/progress/types.js';
+
+describe('ProgressReporter', () => {
+  let reporter: ProgressReporter;
+
+  beforeEach(() => {
+    reporter = new ProgressReporter();
+  });
+
+  describe('scanStart', () => {
+    it('should emit scan:start event', () => {
+      const events: ProgressEvent[] = [];
+      reporter.on('scan:start', (e: ProgressEvent) => events.push(e));
+
+      reporter.scanStart(5);
+
+      expect(events).toHaveLength(1);
+      expect(events[0]!.type).toBe('scan:start');
+      expect(events[0]!.total).toBe(5);
+      expect(events[0]!.completed).toBe(0);
+    });
+  });
+
+  describe('analyzerStart', () => {
+    it('should emit analyzer:start event', () => {
+      const events: ProgressEvent[] = [];
+      reporter.on('analyzer:start', (e: ProgressEvent) => events.push(e));
+
+      reporter.scanStart(3);
+      reporter.analyzerStart('code');
+
+      expect(events).toHaveLength(1);
+      expect(events[0]!.type).toBe('analyzer:start');
+      expect(events[0]!.analyzer).toBe('code');
+    });
+  });
+
+  describe('analyzerComplete', () => {
+    it('should emit analyzer:complete event with duration', () => {
+      const events: ProgressEvent[] = [];
+      reporter.on('analyzer:complete', (e: ProgressEvent) => events.push(e));
+
+      reporter.scanStart(3);
+      reporter.analyzerComplete('code', 150);
+
+      expect(events).toHaveLength(1);
+      expect(events[0]!.type).toBe('analyzer:complete');
+      expect(events[0]!.analyzer).toBe('code');
+      expect(events[0]!.duration).toBe(150);
+      expect(events[0]!.completed).toBe(1);
+    });
+
+    it('should increment completed count', () => {
+      reporter.scanStart(3);
+      reporter.analyzerComplete('a', 10);
+      reporter.analyzerComplete('b', 20);
+
+      expect(reporter.percentage).toBe(67); // 2/3 = 66.67 -> 67
+    });
+  });
+
+  describe('scanComplete', () => {
+    it('should emit scan:complete event', () => {
+      const events: ProgressEvent[] = [];
+      reporter.on('scan:complete', (e: ProgressEvent) => events.push(e));
+
+      reporter.scanStart(2);
+      reporter.analyzerComplete('a', 10);
+      reporter.analyzerComplete('b', 20);
+      reporter.scanComplete(30);
+
+      expect(events).toHaveLength(1);
+      expect(events[0]!.type).toBe('scan:complete');
+      expect(events[0]!.duration).toBe(30);
+      expect(events[0]!.completed).toBe(2);
+    });
+  });
+
+  describe('percentage', () => {
+    it('should return 0 when no analyzers', () => {
+      expect(reporter.percentage).toBe(0);
+    });
+
+    it('should return 0 at start', () => {
+      reporter.scanStart(5);
+      expect(reporter.percentage).toBe(0);
+    });
+
+    it('should return 100 when all complete', () => {
+      reporter.scanStart(2);
+      reporter.analyzerComplete('a', 10);
+      reporter.analyzerComplete('b', 10);
+      expect(reporter.percentage).toBe(100);
+    });
+  });
+
+  describe('callback', () => {
+    it('should call callback on all events', () => {
+      const events: ProgressEvent[] = [];
+      const callbackReporter = new ProgressReporter((e) => events.push(e));
+
+      callbackReporter.scanStart(1);
+      callbackReporter.analyzerStart('code');
+      callbackReporter.analyzerComplete('code', 100);
+      callbackReporter.scanComplete(100);
+
+      expect(events).toHaveLength(4);
+      expect(events.map((e) => e.type)).toEqual([
+        'scan:start',
+        'analyzer:start',
+        'analyzer:complete',
+        'scan:complete',
+      ]);
+    });
+  });
+});