ios-app-review-plugin 1.0.0

package/src/parsers/index.ts

@@ -0,0 +1,3 @@
+export { parsePlist, parsePbxproj, fileExists, readFile } from './plist.js';
+export { parseXcodeProject } from './xcodeproj.js';
+export type { PbxProject, PbxObject } from './plist.js';

package/src/parsers/plist.ts

@@ -0,0 +1,253 @@
+import * as fs from 'fs/promises';
+import * as plist from 'plist';
+
+/**
+ * Parse a plist file (XML or binary format)
+ */
+export async function parsePlist<T = Record<string, unknown>>(filePath: string): Promise<T> {
+  const content = await fs.readFile(filePath, 'utf-8');
+
+  // Try XML plist first
+  try {
+    return plist.parse(content) as T;
+  } catch {
+    // If XML parsing fails, it might be binary plist
+    // The plist library handles both, but let's try with buffer
+    const buffer = await fs.readFile(filePath);
+    return plist.parse(buffer.toString('utf-8')) as T;
+  }
+}
+
+/**
+ * Check if a file exists
+ */
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Read file contents as string
+ */
+export async function readFile(filePath: string): Promise<string> {
+  return fs.readFile(filePath, 'utf-8');
+}
+
+/**
+ * Parse a pbxproj file (OpenStep plist format)
+ * This is a simplified parser for the Xcode project format
+ */
+export function parsePbxproj(content: string): PbxProject {
+  const result: PbxProject = {
+    archiveVersion: '',
+    objectVersion: '',
+    rootObject: '',
+    objects: {},
+  };
+
+  // Extract archive version
+  const archiveMatch = content.match(/archiveVersion\s*=\s*(\d+)/);
+  if (archiveMatch?.[1]) {
+    result.archiveVersion = archiveMatch[1];
+  }
+
+  // Extract object version
+  const objectMatch = content.match(/objectVersion\s*=\s*(\d+)/);
+  if (objectMatch?.[1]) {
+    result.objectVersion = objectMatch[1];
+  }
+
+  // Extract root object
+  const rootMatch = content.match(/rootObject\s*=\s*([A-F0-9]+)/);
+  if (rootMatch?.[1]) {
+    result.rootObject = rootMatch[1];
+  }
+
+  // Parse objects section
+  const objectsMatch = content.match(/objects\s*=\s*\{([\s\S]*)\};\s*rootObject/);
+  if (objectsMatch?.[1]) {
+    result.objects = parseObjects(objectsMatch[1]);
+  }
+
+  return result;
+}
+
+/**
+ * Parse the objects section of a pbxproj file
+ */
+function parseObjects(content: string): Record<string, PbxObject> {
+  const objects: Record<string, PbxObject> = {};
+
+  // Find each object by looking for ID = { pattern and matching braces
+  const idPattern = /([A-F0-9]{24})\s*(?:\/\*[^*]*\*\/)?\s*=\s*\{/g;
+  let idMatch: RegExpExecArray | null;
+
+  while ((idMatch = idPattern.exec(content)) !== null) {
+    const id = idMatch[1];
+    const startBrace = idMatch.index + idMatch[0].length - 1;
+
+    // Find matching closing brace
+    let depth = 1;
+    let pos = startBrace + 1;
+    while (pos < content.length && depth > 0) {
+      const char = content[pos];
+      if (char === '{') {
+        depth++;
+      } else if (char === '}') {
+        depth--;
+      }
+      pos++;
+    }
+
+    if (depth === 0 && id) {
+      const objectContent = content.substring(startBrace + 1, pos - 1);
+      const parsedObj = parseObjectContent(objectContent);
+
+      // Only store if this object has a valid isa, or if we haven't seen this ID before
+      // This handles the case where an ID appears multiple times (e.g., in different sections)
+      if (parsedObj.isa || !objects[id]) {
+        // If the new object has isa, use it; otherwise keep the existing one
+        if (parsedObj.isa || !objects[id]?.isa) {
+          objects[id] = parsedObj;
+        }
+      }
+    }
+  }
+
+  return objects;
+}
+
+/**
+ * Parse individual object content
+ */
+function parseObjectContent(content: string): PbxObject {
+  const obj: PbxObject = { isa: '' };
+
+  // Extract isa (object type)
+  const isaMatch = content.match(/isa\s*=\s*(\w+)/);
+  if (isaMatch?.[1]) {
+    obj.isa = isaMatch[1];
+  }
+
+  // Extract name
+  const nameMatch = content.match(/name\s*=\s*"?([^";]+)"?/);
+  if (nameMatch?.[1]) {
+    obj.name = nameMatch[1].trim();
+  }
+
+  // Extract path
+  const pathMatch = content.match(/path\s*=\s*"?([^";]+)"?/);
+  if (pathMatch?.[1]) {
+    obj.path = pathMatch[1].trim();
+  }
+
+  // Extract productType
+  const productTypeMatch = content.match(/productType\s*=\s*"([^"]+)"/);
+  if (productTypeMatch?.[1]) {
+    obj.productType = productTypeMatch[1];
+  }
+
+  // Extract buildConfigurationList
+  const buildConfigMatch = content.match(/buildConfigurationList\s*=\s*([A-F0-9]{24})/);
+  if (buildConfigMatch?.[1]) {
+    obj.buildConfigurationList = buildConfigMatch[1];
+  }
+
+  // Extract buildSettings (simplified)
+  const buildSettingsMatch = content.match(/buildSettings\s*=\s*\{([^}]+)\}/);
+  if (buildSettingsMatch?.[1]) {
+    obj.buildSettings = parseBuildSettings(buildSettingsMatch[1]);
+  }
+
+  // Extract files array
+  const filesMatch = content.match(/files\s*=\s*\(([^)]*)\)/);
+  if (filesMatch?.[1]) {
+    obj.files = parseArray(filesMatch[1]);
+  }
+
+  // Extract dependencies array
+  const depsMatch = content.match(/dependencies\s*=\s*\(([^)]*)\)/);
+  if (depsMatch?.[1]) {
+    obj.dependencies = parseArray(depsMatch[1]);
+  }
+
+  // Extract buildPhases array
+  const phasesMatch = content.match(/buildPhases\s*=\s*\(([^)]*)\)/);
+  if (phasesMatch?.[1]) {
+    obj.buildPhases = parseArray(phasesMatch[1]);
+  }
+
+  // Extract buildConfigurations array (for XCConfigurationList)
+  const configsMatch = content.match(/buildConfigurations\s*=\s*\(([^)]*)\)/);
+  if (configsMatch?.[1]) {
+    obj['buildConfigurations'] = parseArray(configsMatch[1]);
+  }
+
+  return obj;
+}
+
+/**
+ * Parse build settings
+ */
+function parseBuildSettings(content: string): Record<string, string> {
+  const settings: Record<string, string> = {};
+  const settingRegex = /(\w+)\s*=\s*"?([^";]+)"?/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = settingRegex.exec(content)) !== null) {
+    const key = match[1];
+    const value = match[2];
+    if (key && value) {
+      settings[key] = value.trim();
+    }
+  }
+
+  return settings;
+}
+
+/**
+ * Parse an array from pbxproj format
+ */
+function parseArray(content: string): string[] {
+  const items: string[] = [];
+  const itemRegex = /([A-F0-9]{24})/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = itemRegex.exec(content)) !== null) {
+    if (match[1]) {
+      items.push(match[1]);
+    }
+  }
+
+  return items;
+}
+
+/**
+ * PBX project structure
+ */
+export interface PbxProject {
+  archiveVersion: string;
+  objectVersion: string;
+  rootObject: string;
+  objects: Record<string, PbxObject>;
+}
+
+/**
+ * PBX object (generic)
+ */
+export interface PbxObject {
+  isa: string;
+  name?: string;
+  path?: string;
+  productType?: string;
+  buildConfigurationList?: string;
+  buildSettings?: Record<string, string>;
+  files?: string[];
+  dependencies?: string[];
+  buildPhases?: string[];
+  [key: string]: unknown;
+}

package/src/parsers/xcodeproj.ts

@@ -0,0 +1,265 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { parsePbxproj, fileExists, type PbxProject, type PbxObject } from './plist.js';
+import type { XcodeProject, XcodeTarget, TargetType } from '../types/index.js';
+
+/**
+ * Parse an Xcode project or workspace
+ */
+export async function parseXcodeProject(projectPath: string): Promise<XcodeProject> {
+  const stats = await fs.stat(projectPath);
+
+  if (stats.isDirectory()) {
+    if (projectPath.endsWith('.xcworkspace')) {
+      return parseWorkspace(projectPath);
+    } else if (projectPath.endsWith('.xcodeproj')) {
+      return parseProject(projectPath);
+    }
+  }
+
+  throw new Error(
+    `Invalid project path: ${projectPath}. Expected .xcodeproj or .xcworkspace directory.`
+  );
+}
+
+/**
+ * Parse an .xcodeproj directory
+ */
+async function parseProject(projectPath: string): Promise<XcodeProject> {
+  const pbxprojPath = path.join(projectPath, 'project.pbxproj');
+
+  if (!(await fileExists(pbxprojPath))) {
+    throw new Error(`project.pbxproj not found at ${pbxprojPath}`);
+  }
+
+  const content = await fs.readFile(pbxprojPath, 'utf-8');
+  const pbxProject = parsePbxproj(content);
+
+  const projectName = path.basename(projectPath, '.xcodeproj');
+  const basePath = path.dirname(projectPath);
+
+  // Extract targets
+  const targets = extractTargets(pbxProject, basePath);
+
+  // Extract configurations
+  const configurations = extractConfigurations(pbxProject);
+
+  return {
+    path: projectPath,
+    name: projectName,
+    targets,
+    configurations,
+  };
+}
+
+/**
+ * Parse an .xcworkspace directory
+ */
+async function parseWorkspace(workspacePath: string): Promise<XcodeProject> {
+  const contentsPath = path.join(workspacePath, 'contents.xcworkspacedata');
+
+  if (!(await fileExists(contentsPath))) {
+    throw new Error(`contents.xcworkspacedata not found at ${contentsPath}`);
+  }
+
+  const content = await fs.readFile(contentsPath, 'utf-8');
+
+  // Extract project references from workspace
+  const projectRefs = extractWorkspaceProjects(content);
+  const basePath = path.dirname(workspacePath);
+
+  // Find the main project (usually the one with the same name as the workspace)
+  const workspaceName = path.basename(workspacePath, '.xcworkspace');
+  let mainProjectPath: string | undefined;
+
+  for (const ref of projectRefs) {
+    const fullPath = path.resolve(basePath, ref);
+    if (ref.includes(workspaceName) && (await fileExists(fullPath))) {
+      mainProjectPath = fullPath;
+      break;
+    }
+  }
+
+  // Fallback to first project if no matching name
+  if (!mainProjectPath && projectRefs.length > 0 && projectRefs[0]) {
+    mainProjectPath = path.resolve(basePath, projectRefs[0]);
+  }
+
+  if (!mainProjectPath) {
+    throw new Error(`No projects found in workspace ${workspacePath}`);
+  }
+
+  // Parse the main project
+  const project = await parseProject(mainProjectPath);
+  project.path = workspacePath;
+  project.name = workspaceName;
+
+  return project;
+}
+
+/**
+ * Extract project paths from workspace data
+ */
+function extractWorkspaceProjects(content: string): string[] {
+  const projects: string[] = [];
+  const locationRegex = /location\s*=\s*"group:([^"]+\.xcodeproj)"/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = locationRegex.exec(content)) !== null) {
+    if (match[1]) {
+      projects.push(match[1]);
+    }
+  }
+
+  return projects;
+}
+
+/**
+ * Extract targets from a pbxproj
+ */
+function extractTargets(pbxProject: PbxProject, basePath: string): XcodeTarget[] {
+  const targets: XcodeTarget[] = [];
+  const objects = pbxProject.objects;
+
+  // Find native targets
+  for (const obj of Object.values(objects)) {
+    if (obj.isa === 'PBXNativeTarget') {
+      const target = extractTarget(obj, objects, basePath);
+      if (target) {
+        targets.push(target);
+      }
+    }
+  }
+
+  return targets;
+}
+
+/**
+ * Extract a single target's information
+ */
+function extractTarget(
+  targetObj: PbxObject,
+  objects: Record<string, PbxObject>,
+  basePath: string
+): XcodeTarget | null {
+  const name = targetObj.name ?? 'Unknown';
+  const type = mapProductType(targetObj.productType);
+
+  // Get build settings from build configuration list
+  let bundleIdentifier: string | undefined;
+  let infoPlistPath: string | undefined;
+  let entitlementsPath: string | undefined;
+  let deploymentTarget: string | undefined;
+
+  if (targetObj.buildConfigurationList) {
+    const configList = objects[targetObj.buildConfigurationList];
+    if (configList && configList.isa === 'XCConfigurationList') {
+      // Get build configurations
+      const buildConfigs = (configList['buildConfigurations'] as string[] | undefined) ?? [];
+      for (const configId of buildConfigs) {
+        const config = objects[configId];
+        if (config?.buildSettings) {
+          const settings = config.buildSettings;
+          bundleIdentifier = bundleIdentifier ?? settings['PRODUCT_BUNDLE_IDENTIFIER'];
+          infoPlistPath = infoPlistPath ?? settings['INFOPLIST_FILE'];
+          entitlementsPath = entitlementsPath ?? settings['CODE_SIGN_ENTITLEMENTS'];
+          deploymentTarget = deploymentTarget ?? settings['IPHONEOS_DEPLOYMENT_TARGET'];
+        }
+      }
+    }
+  }
+
+  // Resolve paths relative to project
+  if (infoPlistPath) {
+    infoPlistPath = path.resolve(basePath, infoPlistPath);
+  }
+  if (entitlementsPath) {
+    entitlementsPath = path.resolve(basePath, entitlementsPath);
+  }
+
+  // Extract source files
+  const sourceFiles = extractSourceFiles(targetObj, objects, basePath);
+
+  return {
+    name,
+    type,
+    bundleIdentifier,
+    infoPlistPath,
+    entitlementsPath,
+    deploymentTarget,
+    sourceFiles,
+  };
+}
+
+/**
+ * Map Xcode product type to our TargetType
+ */
+function mapProductType(productType: string | undefined): TargetType {
+  if (!productType) {
+    return 'unknown';
+  }
+
+  const typeMap: Record<string, TargetType> = {
+    'com.apple.product-type.application': 'application',
+    'com.apple.product-type.framework': 'framework',
+    'com.apple.product-type.library.static': 'staticLibrary',
+    'com.apple.product-type.library.dynamic': 'dynamicLibrary',
+    'com.apple.product-type.app-extension': 'appExtension',
+    'com.apple.product-type.application.watchapp2': 'watchApp',
+    'com.apple.product-type.watchkit2-extension': 'watchExtension',
+    'com.apple.product-type.tv-app-extension': 'tvExtension',
+    'com.apple.product-type.bundle.unit-test': 'unitTest',
+    'com.apple.product-type.bundle.ui-testing': 'uiTest',
+  };
+
+  return typeMap[productType] ?? 'unknown';
+}
+
+/**
+ * Extract source files from a target
+ */
+function extractSourceFiles(
+  targetObj: PbxObject,
+  objects: Record<string, PbxObject>,
+  basePath: string
+): string[] {
+  const sourceFiles: string[] = [];
+
+  // Find Sources build phase
+  const buildPhases = targetObj.buildPhases ?? [];
+  for (const phaseId of buildPhases) {
+    const phase = objects[phaseId];
+    if (phase?.isa === 'PBXSourcesBuildPhase') {
+      const files = phase.files ?? [];
+      for (const fileId of files) {
+        const buildFile = objects[fileId];
+        if (buildFile) {
+          const fileRef = buildFile['fileRef'] as string | undefined;
+          if (fileRef) {
+            const fileRefObj = objects[fileRef];
+            if (fileRefObj?.path) {
+              sourceFiles.push(path.resolve(basePath, fileRefObj.path));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return sourceFiles;
+}
+
+/**
+ * Extract build configurations
+ */
+function extractConfigurations(pbxProject: PbxProject): string[] {
+  const configs = new Set<string>();
+
+  for (const obj of Object.values(pbxProject.objects)) {
+    if (obj.isa === 'XCBuildConfiguration' && obj.name) {
+      configs.add(obj.name);
+    }
+  }
+
+  return Array.from(configs);
+}

package/src/progress/index.ts

@@ -0,0 +1,2 @@
+export { ProgressReporter } from './reporter.js';
+export type { ProgressEvent, ProgressCallback } from './types.js';

package/src/progress/reporter.ts

@@ -0,0 +1,65 @@
+import { EventEmitter } from 'events';
+import type { ProgressEvent, ProgressCallback } from './types.js';
+
+export class ProgressReporter extends EventEmitter {
+  private total = 0;
+  private completed = 0;
+  private callback?: ProgressCallback | undefined;
+
+  constructor(callback?: ProgressCallback) {
+    super();
+    this.callback = callback;
+  }
+
+  scanStart(totalAnalyzers: number): void {
+    this.total = totalAnalyzers;
+    this.completed = 0;
+    const event: ProgressEvent = {
+      type: 'scan:start',
+      total: this.total,
+      completed: 0,
+    };
+    this.emit('scan:start', event);
+    this.callback?.(event);
+  }
+
+  analyzerStart(name: string): void {
+    const event: ProgressEvent = {
+      type: 'analyzer:start',
+      analyzer: name,
+      total: this.total,
+      completed: this.completed,
+    };
+    this.emit('analyzer:start', event);
+    this.callback?.(event);
+  }
+
+  analyzerComplete(name: string, duration: number): void {
+    this.completed++;
+    const event: ProgressEvent = {
+      type: 'analyzer:complete',
+      analyzer: name,
+      total: this.total,
+      completed: this.completed,
+      duration,
+    };
+    this.emit('analyzer:complete', event);
+    this.callback?.(event);
+  }
+
+  scanComplete(totalDuration: number): void {
+    const event: ProgressEvent = {
+      type: 'scan:complete',
+      total: this.total,
+      completed: this.completed,
+      duration: totalDuration,
+    };
+    this.emit('scan:complete', event);
+    this.callback?.(event);
+  }
+
+  get percentage(): number {
+    if (this.total === 0) return 0;
+    return Math.round((this.completed / this.total) * 100);
+  }
+}

package/src/progress/types.ts

@@ -0,0 +1,9 @@
+export interface ProgressEvent {
+  type: 'analyzer:start' | 'analyzer:complete' | 'scan:start' | 'scan:complete';
+  analyzer?: string;
+  total?: number;
+  completed?: number;
+  duration?: number;
+}
+
+export type ProgressCallback = (event: ProgressEvent) => void;