ai-first-cli 1.1.1 → 1.1.2

package/src/analyzers/dependencies.ts

@@ -66,6 +66,8 @@ function parseFileForDependencies(file: FileInfo): Dependency[] {
       deps.push(...parseRustImports(content, file.relativePath));
     } else if (file.extension === "java" || file.extension === "cs") {
       deps.push(...parseJavaImports(content, file.relativePath));
+    } else if (file.extension === "gradle" || file.extension === "gradle.kts") {
+      deps.push(...parseGradleDependencies(content, file.relativePath));
     }
   } catch {}
 
@@ -305,3 +307,42 @@ export function generateDependenciesJson(analysis: DependencyAnalysis): string {
   };
   return JSON.stringify(output, null, 2);
 }
+
+/**
+ * Parse Gradle dependencies from build.gradle files
+ */
+function parseGradleDependencies(content: string, sourceFile: string): Dependency[] {
+  const deps: Dependency[] = [];
+  
+  // implementation "com.example:library:1.0"
+  const implMatches = content.matchAll(/(?:implementation|api|compile|testImplementation|androidTestImplementation)\s+["\']([@\w.\-]+):([@\w.\-]+):([@\w.\-]+)["\']/g);
+  for (const match of implMatches) {
+    deps.push({
+      source: sourceFile,
+      target: `${match[1]}:${match[2]}:${match[3]}`,
+      type: "import",
+    });
+  }
+  
+  // implementation project(":module")
+  const projMatches = content.matchAll(/implementation\s+project\s*\(\s*["\']([@\w.\-]+)["\']\s*\)/g);
+  for (const match of projMatches) {
+    deps.push({
+      source: sourceFile,
+      target: `project:${match[1]}`,
+      type: "import",
+    });
+  }
+  
+  // include ":module"
+  const includeMatches = content.matchAll(/include\s*\(\s*["\']([@\w.\-]+)["\']\s*\)/g);
+  for (const match of includeMatches) {
+    deps.push({
+      source: sourceFile,
+      target: `module:${match[1]}`,
+      type: "include",
+    });
+  }
+  
+  return deps;
+}

package/src/analyzers/entrypoints.ts

@@ -1,5 +1,5 @@
 import { FileInfo } from "../core/repoScanner.js";
-import { readJsonFile } from "../utils/fileUtils.js";
+import { readJsonFile, readFile } from "../utils/fileUtils.js";
 import path from "path";
 
 export interface Entrypoint {
@@ -69,6 +69,85 @@ export function discoverEntrypoints(files: FileInfo[], rootDir: string): Entrypo
     }
   }
   
+  // Detect Android entrypoints from AndroidManifest.xml
+  const androidManifests = files.filter(f => f.name === "AndroidManifest.xml");
+  for (const manifest of androidManifests) {
+    try {
+      const manifestContent = readFile(path.join(rootDir, manifest.relativePath));
+      const androidEntrypoints = parseAndroidManifest(manifestContent, manifest.relativePath);
+      entrypoints.push(...androidEntrypoints);
+    } catch {}
+  }
+  
+  return entrypoints;
+}
+
+/**
+ * Parse AndroidManifest.xml to extract entrypoints
+ */
+function parseAndroidManifest(content: string, manifestPath: string): Entrypoint[] {
+  const entrypoints: Entrypoint[] = [];
+  
+  // Extract package name
+  const packageMatch = content.match(/package="([^"]+)"/);
+  const packageName = packageMatch ? packageMatch[1] : "unknown";
+  
+  // Extract activities
+  const activityRegex = /<activity[^>]+android:name="([^"]+)"[^>]*>/g;
+  let match;
+  while ((match = activityRegex.exec(content)) !== null) {
+    const activityName = match[1];
+    const isMain = content.includes(`android:name="${activityName}"`) && 
+                   content.includes("android.intent.action.MAIN") &&
+                   content.includes("android.intent.category.LAUNCHER");
+    
+    entrypoints.push({
+      name: activityName.split('.').pop() || activityName,
+      path: `${manifestPath}#${activityName}`,
+      type: isMain ? "client" : "other",
+      description: isMain ? `Main Activity (${packageName})` : `Activity: ${activityName}`,
+      command: isMain ? `adb shell am start -n ${packageName}/${activityName}` : undefined,
+    });
+  }
+  
+  // Extract services
+  const serviceRegex = /<service[^>]+android:name="([^"]+)"[^>]*>/g;
+  while ((match = serviceRegex.exec(content)) !== null) {
+    entrypoints.push({
+      name: match[1].split('.').pop() || match[1],
+      path: `${manifestPath}#service.${match[1]}`,
+      type: "other",
+      description: `Service: ${match[1]}`,
+    });
+  }
+  
+  // Extract receivers
+  const receiverRegex = /<receiver[^>]+android:name="([^"]+)"[^>]*>/g;
+  while ((match = receiverRegex.exec(content)) !== null) {
+    entrypoints.push({
+      name: match[1].split('.').pop() || match[1],
+      path: `${manifestPath}#receiver.${match[1]}`,
+      type: "other",
+      description: `BroadcastReceiver: ${match[1]}`,
+    });
+  }
+  
+  // Extract permissions
+  const permissionRegex = /<uses-permission[^>]+android:name="([^"]+)"[^>]*>/g;
+  const permissions: string[] = [];
+  while ((match = permissionRegex.exec(content)) !== null) {
+    permissions.push(match[1]);
+  }
+  
+  if (permissions.length > 0) {
+    entrypoints.push({
+      name: "Permissions",
+      path: `${manifestPath}#permissions`,
+      type: "config",
+      description: `${permissions.length} permissions declared`,
+    });
+  }
+  
   return entrypoints;
 }
 

package/src/analyzers/gradleModules.ts

@@ -0,0 +1,100 @@
+import { FileInfo } from "../core/repoScanner.js";
+import { readFile } from "../utils/fileUtils.js";
+import path from "path";
+
+export interface GradleModule {
+  name: string;
+  path: string;
+  isIncluded: boolean;
+}
+
+export interface GradleModulesAnalysis {
+  isGradle: boolean;
+  isMultiModule: boolean;
+  modules: GradleModule[];
+  rootProjectName?: string;
+  settingsFile?: string;
+}
+
+/**
+ * Analyze Gradle settings to detect modules
+ */
+export function analyzeGradleModules(files: FileInfo[], rootDir: string): GradleModulesAnalysis {
+  const settingsFiles = files.filter(f => 
+    f.name === "settings.gradle" || f.name === "settings.gradle.kts"
+  );
+  
+  if (settingsFiles.length === 0) {
+    return {
+      isGradle: false,
+      isMultiModule: false,
+      modules: [],
+    };
+  }
+  
+  const modules: GradleModule[] = [];
+  let rootProjectName = "app";
+  let settingsContent = "";
+  
+  // Use root settings.gradle or settings.gradle.kts
+  const settingsFile = settingsFiles.find(f => f.relativePath === "settings.gradle" || f.relativePath === "settings.gradle.kts");
+  
+  if (settingsFile) {
+    try {
+      settingsContent = readFile(path.join(rootDir, settingsFile.relativePath));
+    } catch {}
+  }
+  
+  // Parse include statements: include(":module")
+  const includeMatches = settingsContent.matchAll(/include\s*\(\s*["']([^"']+)["']\s*\)/g);
+  for (const match of includeMatches) {
+    const modulePath = match[1];
+    modules.push({
+      name: modulePath.replace(/^:/, ""),
+      path: modulePath,
+      isIncluded: true,
+    });
+  }
+  
+  // Parse project statements: project(":module")
+  const projectMatches = settingsContent.matchAll(/project\s*\(\s*["']([^"']+)["']\s*\)\s*\.+/g);
+  for (const match of projectMatches) {
+    const modulePath = match[1];
+    const moduleName = modulePath.replace(/^:/, "");
+    if (!modules.find(m => m.name === moduleName)) {
+      modules.push({
+        name: moduleName,
+        path: modulePath,
+        isIncluded: true,
+      });
+    }
+  }
+  
+  // Extract root project name
+  const rootNameMatch = settingsContent.match(/rootProject\s*\(\s*["']name["']\s*=\s*["']([^"']+)["']/);
+  if (rootNameMatch) {
+    rootProjectName = rootNameMatch[1];
+  }
+  
+  return {
+    isGradle: true,
+    isMultiModule: modules.length > 0,
+    modules,
+    rootProjectName,
+    settingsFile: settingsFile?.relativePath,
+  };
+}
+
+/**
+ * Generate gradle-modules.json content
+ */
+export function generateGradleModulesJson(analysis: GradleModulesAnalysis): string {
+  const output = {
+    isGradle: analysis.isGradle,
+    isMultiModule: analysis.isMultiModule,
+    rootProjectName: analysis.rootProjectName,
+    settingsFile: analysis.settingsFile,
+    modules: analysis.modules,
+  };
+  return JSON.stringify(output, null, 2);
+}

package/src/analyzers/techStack.ts

@@ -12,6 +12,13 @@ export interface TechStack {
   linters: string[];
   formatters: string[];
   description: string;
+  android?: {
+    minSdk?: string;
+    targetSdk?: string;
+    compileSdk?: string;
+    gradleVersion?: string;
+    kotlinVersion?: string;
+  };
 }
 
 /**
@@ -34,6 +41,8 @@ export function detectTechStack(files: FileInfo[], rootDir: string): TechStack {
     languages, frameworks, libraries, tools, packageManagers, testing, linters, formatters
   );
   
+  const android = detectAndroidSDK(files, rootDir);
+  
   return {
     languages,
     frameworks,
@@ -44,6 +53,7 @@ export function detectTechStack(files: FileInfo[], rootDir: string): TechStack {
     linters,
     formatters,
     description,
+    android,
   };
 }
 
@@ -127,6 +137,10 @@ function detectFrameworks(files: FileInfo[], fileNames: Set<string>, rootDir: st
     "postcss.config": "PostCSS",
     "babel.config": "Babel",
     "tsconfig": "TypeScript",
+    "build.gradle": "Android",
+    "build.gradle.kts": "Android",
+    "settings.gradle": "Android",
+    "AndroidManifest.xml": "Android",
   };
   
   for (const [indicator, framework] of Object.entries(frameworkIndicators)) {
@@ -303,6 +317,48 @@ function detectFormatters(files: FileInfo[], fileNames: Set<string>): string[] {
   return formatters;
 }
 
+/**
+ * Detect Android SDK versions from build.gradle files
+ */
+function detectAndroidSDK(files: FileInfo[], rootDir: string): TechStack["android"] {
+  const fileNames = files.map(f => f.name);
+  const hasAndroid = fileNames.some(n => 
+    n === "build.gradle" || n === "build.gradle.kts" || 
+    n === "app/build.gradle" || n === "app/build.gradle.kts"
+  );
+  
+  if (!hasAndroid) return undefined;
+  
+  const android: TechStack["android"] = {};
+  
+  const gradleFiles = files.filter(f => 
+    f.name === "build.gradle" || f.name === "build.gradle.kts" ||
+    f.relativePath.includes("app/build.gradle")
+  );
+  
+  for (const gf of gradleFiles) {
+    try {
+      const content = readFile(path.join(rootDir, gf.relativePath));
+      const minSdkMatch = content.match(/minSdk(?:Version)?\s*[=:]\s*(\d+)/);
+      const targetSdkMatch = content.match(/targetSdk(?:Version)?\s*[=:]\s*(\d+)/);
+      const compileSdkMatch = content.match(/compileSdk(?:Version)?\s*[=:]\s*(\d+)/);
+      
+      if (minSdkMatch && !android.minSdk) android.minSdk = minSdkMatch[1];
+      if (targetSdkMatch && !android.targetSdk) android.targetSdk = targetSdkMatch[1];
+      if (compileSdkMatch && !android.compileSdk) android.compileSdk = compileSdkMatch[1];
+    } catch {}
+  }
+  
+  try {
+    const propsPath = path.join(rootDir, "gradle/wrapper/gradle-wrapper.properties");
+    const props = readFile(propsPath);
+    const v = props.match(/gradle-(\d+\.\d+)/);
+    if (v) android.gradleVersion = v[1];
+  } catch {}
+  
+  return (android.minSdk || android.targetSdk || android.compileSdk || android.gradleVersion) ? android : undefined;
+}
+
 /**
  * Generate tech stack description
  */