@antomanc/aginit 0.4.0 → 0.5.0

package/src/detect/index.ts

@@ -0,0 +1,134 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readJsonFile, readTextFile } from '../utils/fs.js';
+import { PackageManager } from '../config/schema.js';
+import { getPackageManagerAdapter } from '../adapters/package-manager.js';
+import { Platform, ProjectCommands, Stack } from '../registry/types.js';
+
+export interface DetectedProject {
+  /** null when nothing marks the platform (empty directory). */
+  platform: Platform | null;
+  stack: Stack;
+}
+
+const WEB_FRAMEWORKS = [
+  'next',
+  'vite',
+  'astro',
+  'react',
+  'react-dom',
+  'vue',
+  'nuxt',
+  'svelte',
+  '@sveltejs/kit',
+  '@angular/core',
+  'solid-js',
+  '@remix-run/react',
+  'preact'
+];
+
+function entries(dir: string): string[] {
+  try {
+    return fs.readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+const hasXcodeProject = (dir: string) => entries(dir).some((name) => name.endsWith('.xcodeproj'));
+
+function gradleFiles(dir: string): string[] {
+  return ['build.gradle', 'build.gradle.kts', 'settings.gradle', 'settings.gradle.kts']
+    .map((name) => readTextFile(path.join(dir, name)))
+    .filter((text): text is string => text !== null);
+}
+
+/** Read the project's markers (pubspec.yaml, Package.swift, gradle, package.json, ...). */
+export function detectProject(dir: string): DetectedProject {
+  const exists = (file: string) => fs.existsSync(path.join(dir, file));
+  const pkg = readJsonFile<Record<string, any>>(path.join(dir, 'package.json'));
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+
+  if (exists('pubspec.yaml')) return { platform: 'mobile-native', stack: 'flutter' };
+  const expoApp = /"expo"\s*:/.test(readTextFile(path.join(dir, 'app.json')) ?? '');
+  if (deps['react-native'] || deps.expo || expoApp)
+    return { platform: 'mobile-rn', stack: 'react-native' };
+  if (exists('Package.swift') || hasXcodeProject(dir) || hasXcodeProject(path.join(dir, 'ios'))) {
+    const manifest = readTextFile(path.join(dir, 'Package.swift')) ?? '';
+    const apple = !exists('Package.swift') || /\.(iOS|macOS|tvOS|watchOS|visionOS)\(/.test(manifest);
+    return { platform: apple ? 'mobile-native' : 'cli', stack: 'swift' };
+  }
+  const androidGradle = gradleFiles(path.join(dir, 'android'));
+  const rootGradle = gradleFiles(dir);
+  if (androidGradle.length > 0 || rootGradle.some((text) => /com\.android|android\s*\{/.test(text)))
+    return { platform: 'mobile-native', stack: 'kotlin' };
+  if (pkg) {
+    const web = WEB_FRAMEWORKS.some((name) => deps[name]);
+    return { platform: web ? 'web' : 'cli', stack: 'node' };
+  }
+  if (rootGradle.length > 0) return { platform: 'backend', stack: 'kotlin' };
+  if (exists('Cargo.toml')) return { platform: 'cli', stack: 'rust' };
+  if (exists('go.mod')) return { platform: 'backend', stack: 'go' };
+  if (exists('pyproject.toml') || exists('requirements.txt'))
+    return { platform: 'backend', stack: 'python' };
+  return { platform: null, stack: 'unknown' };
+}
+
+/**
+ * The project's own commands: package scripts for Node projects, the host
+ * toolchain otherwise. Commands that would be guesses are left out.
+ */
+export function projectCommands(
+  dir: string,
+  stack: Stack,
+  options: { packageManager?: PackageManager; scripts?: Record<string, string> } = {}
+): ProjectCommands {
+  const exists = (file: string) => fs.existsSync(path.join(dir, file));
+  switch (stack) {
+    case 'node':
+    case 'react-native': {
+      const scripts =
+        options.scripts ??
+        readJsonFile<Record<string, any>>(path.join(dir, 'package.json'))?.scripts ??
+        {};
+      const pm = getPackageManagerAdapter(options.packageManager);
+      const run = (name: string) => (Object.hasOwn(scripts, name) ? pm.runCmd(name) : undefined);
+      return {
+        dev: run('dev'),
+        build: run('build'),
+        typecheck: run('typecheck'),
+        lint: run('lint'),
+        test: run('test'),
+        unitTest: run('test:unit'),
+        e2e: run('test:e2e')
+      };
+    }
+    case 'flutter':
+      return { lint: 'flutter analyze', test: 'flutter test' };
+    case 'swift':
+      return exists('Package.swift')
+        ? { build: 'swift build', test: 'swift test' }
+        : {
+            build: 'xcodebuild build -scheme <Scheme>',
+            test: "xcodebuild test -scheme <Scheme> -destination 'platform=iOS Simulator,name=<Device>'"
+          };
+    case 'kotlin': {
+      const nested = fs.existsSync(path.join(dir, 'android'));
+      const android = nested || gradleFiles(dir).some((text) => /com\.android|android\s*\{/.test(text));
+      const gradlew = nested ? 'cd android && ./gradlew' : './gradlew';
+      return {
+        build: `${gradlew} build`,
+        ...(android ? { lint: `${gradlew} lint` } : {}),
+        test: `${gradlew} test`
+      };
+    }
+    case 'rust':
+      return { build: 'cargo build', typecheck: 'cargo check', lint: 'cargo clippy', test: 'cargo test' };
+    case 'go':
+      return { build: 'go build ./...', lint: 'go vet ./...', test: 'go test ./...' };
+    case 'python':
+      return { test: exists('uv.lock') ? 'uv run pytest' : 'pytest' };
+    case 'unknown':
+      return {};
+  }
+}

package/src/index.ts

@@ -14,3 +14,8 @@ export * from './cli/new.js';
 export * from './cli/init.js';
 export * from './cli/doctor.js';
 export * from './cli/wizard.js';
+export * from './registry/index.js';
+export * from './detect/index.js';
+export * from './adapters/agent-docs.js';
+export * from './adapters/e2e.js';
+export * from './cli/capabilities.js';

package/src/presets/cli.ts

@@ -4,6 +4,7 @@ import { PresetContext, PresetHandler } from './types.js';
 import { readPackageManifest } from '../config/validation.js';
 import { addTestingDependencies, setupTesting, VITEST_VERSION } from './testing.js';
 import { setupAdr } from './adr.js';
+import { activeIds } from '../registry/index.js';
 
 export const cliPreset: PresetHandler = {
   name: 'cli',
@@ -14,6 +15,11 @@ export const cliPreset: PresetHandler = {
 
     const existing = readPackageManifest(targetDir);
     if (existing) {
+      // An existing project keeps its own runner unless Vitest is a selected capability.
+      if (!activeIds(ctx.config).has('vitest')) {
+        if (ctx.config.docs.adr) setupAdr(targetDir, { dryRun, silent });
+        return;
+      }
       const hadVitestScript = Object.values(existing.scripts || {}).some(
         (script) => typeof script === 'string' && /^vitest(?:\s|$)/.test(script)
       );

package/src/presets/generic.ts

@@ -3,6 +3,7 @@ import { fileExists, writeJsonFile } from '../utils/fs.js';
 import { PresetContext, PresetHandler } from './types.js';
 import { addTestingDependencies, setupTesting } from './testing.js';
 import { setupAdr } from './adr.js';
+import { activeIds } from '../registry/index.js';
 
 export const genericPreset: PresetHandler = {
   name: 'generic',
@@ -10,8 +11,10 @@ export const genericPreset: PresetHandler = {
   async scaffold(ctx: PresetContext): Promise<void> {
     const { targetDir, projectName, dryRun, silent } = ctx;
 
+    // Only a Vitest harness needs a root package.json; Flutter, Swift, Kotlin,
+    // Rust, Go and Python projects stay free of Node files.
     const pkgPath = path.join(targetDir, 'package.json');
-    if (!fileExists(pkgPath)) {
+    if (!fileExists(pkgPath) && activeIds(ctx.config).has('vitest')) {
       const pkg = {
         name: projectName,
         version: '0.1.0',

package/src/presets/testing.ts

@@ -1,17 +1,24 @@
+import fs from 'node:fs';
 import path from 'node:path';
 import { safeWriteFile, fileExists } from '../utils/fs.js';
 import { PresetContext } from './types.js';
 
 export const VITEST_VERSION = '^4.1.11';
-export function addTestingDependencies(pkg: Record<string, any>, playwright = false): void {
+export function addTestingDependencies(
+  pkg: Record<string, any>,
+  playwright = false,
+  vitest = true
+): void {
   pkg.scripts ??= {};
   pkg.devDependencies ??= {};
-  if (!pkg.dependencies?.vitest && !pkg.devDependencies.vitest)
-    pkg.devDependencies.vitest = VITEST_VERSION;
-  const customTest = pkg.scripts.test && !/^vitest(?:\s|$)/.test(pkg.scripts.test);
-  const testScript = customTest ? 'test:unit' : 'test';
-  pkg.scripts[testScript] ??= 'vitest run';
-  pkg.scripts[customTest ? 'test:unit:watch' : 'test:watch'] ??= 'vitest';
+  if (vitest) {
+    if (!pkg.dependencies?.vitest && !pkg.devDependencies.vitest)
+      pkg.devDependencies.vitest = VITEST_VERSION;
+    const customTest = pkg.scripts.test && !/^vitest(?:\s|$)/.test(pkg.scripts.test);
+    const testScript = customTest ? 'test:unit' : 'test';
+    pkg.scripts[testScript] ??= 'vitest run';
+    pkg.scripts[customTest ? 'test:unit:watch' : 'test:watch'] ??= 'vitest';
+  }
   if (playwright) {
     pkg.scripts['test:e2e'] ??= 'playwright test';
     if (!pkg.dependencies?.['@playwright/test'] && !pkg.devDependencies['@playwright/test'])
@@ -39,9 +46,19 @@ export function setupTesting(ctx: PresetContext, preserveViteTestConfig = false)
       `import { defineConfig } from 'vitest/config';\n\nexport default defineConfig({\n  test: { include: ['tests/**/*.test.{js,ts}'] }\n});\n`,
       { dryRun, silent }
     );
-  safeWriteFile(
-    path.join(targetDir, 'tests', 'aginit.test.js'),
-    `import { it, expect } from 'vitest';
+  // A project that already has tests needs no placeholder.
+  let hasTests = false;
+  try {
+    hasTests = fs
+      .readdirSync(path.join(targetDir, 'tests'))
+      .some((name) => /\.(test|spec)\.[cm]?[jt]sx?$/.test(name) && name !== 'aginit.test.js');
+  } catch {
+    // no tests/ directory yet
+  }
+  if (!hasTests)
+    safeWriteFile(
+      path.join(targetDir, 'tests', 'aginit.test.js'),
+      `import { it, expect } from 'vitest';
 import { readFileSync } from 'node:fs';
 
 // Starter harness: add application behavior tests as the project takes shape.
@@ -51,6 +68,6 @@ it('has a valid project manifest', () => {
   expect(pkg.name.length).toBeGreaterThan(0);
 });
 `,
-    { dryRun, silent }
-  );
+      { dryRun, silent }
+    );
 }

package/src/presets/web.ts

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { fileExists, safeWriteFile, writeJsonFile } from '../utils/fs.js';
+import { fileExists, readTextFile, safeWriteFile, writeJsonFile } from '../utils/fs.js';
 import { readPackageManifest } from '../config/validation.js';
 import { runExecutable } from '../utils/shell.js';
 import { PresetContext, PresetHandler } from './types.js';
@@ -7,6 +7,35 @@ import { setupBrowserTesting } from '../adapters/browser.js';
 import { setupAdr } from './adr.js';
 import { scaffoldCommand } from '../adapters/package-manager.js';
 import { addTestingDependencies, setupTesting } from './testing.js';
+import { activeIds } from '../registry/index.js';
+
+/** Plain tsc cannot resolve framework virtual modules or single-file components,
+ * so those frameworks get their own checker (and the package that provides it). */
+function typecheckFor(
+  pkg: Record<string, any>,
+  targetDir: string,
+  freshNext: boolean
+): { script: string; checker?: [string, string] } {
+  const has = (name: string) => Boolean(pkg.dependencies?.[name] || pkg.devDependencies?.[name]);
+  if (freshNext) return { script: 'next typegen && tsc --noEmit' };
+  if (has('astro')) return { script: 'astro check', checker: ['@astrojs/check', '^0.9.10'] };
+  if (has('nuxt')) return { script: 'nuxi typecheck', checker: ['vue-tsc', '^3.3.13'] };
+  if (has('@sveltejs/kit'))
+    return {
+      script: 'svelte-kit sync && svelte-check --tsconfig ./tsconfig.json',
+      checker: ['svelte-check', '^4.7.6']
+    };
+  if (has('svelte')) return { script: 'svelte-check', checker: ['svelte-check', '^4.7.6'] };
+  // A solution-style tsconfig (Vite templates) has no files of its own: only build mode checks
+  // the referenced projects.
+  const build = /"references"\s*:/.test(readTextFile(path.join(targetDir, 'tsconfig.json')) || '');
+  if (has('vue'))
+    return {
+      script: build ? 'vue-tsc -b --noEmit' : 'vue-tsc --noEmit',
+      checker: ['vue-tsc', '^3.3.13']
+    };
+  return { script: build ? 'tsc -b --noEmit' : 'tsc --noEmit' };
+}
 
 export const webPreset: PresetHandler = {
   name: 'web',
@@ -53,10 +82,15 @@ export const webPreset: PresetHandler = {
     const hadVitestScript = Object.values(pkg.scripts || {}).some(
       (script) => typeof script === 'string' && /^vitest(?:\s|$)/.test(script)
     );
-    addTestingDependencies(pkg, config.browser.playwright);
+    const vitest = activeIds(config).has('vitest');
+    addTestingDependencies(pkg, config.browser.playwright, vitest);
     if (fileExists(path.join(targetDir, 'tsconfig.json'))) {
-      pkg.scripts.typecheck ??=
-        fresh && framework === 'next' ? 'next typegen && tsc --noEmit' : 'tsc --noEmit';
+      if (pkg.scripts.typecheck === undefined) {
+        const { script, checker } = typecheckFor(pkg, targetDir, fresh && framework === 'next');
+        pkg.scripts.typecheck = script;
+        if (checker && !pkg.dependencies?.[checker[0]] && !pkg.devDependencies[checker[0]])
+          pkg.devDependencies[checker[0]] = checker[1];
+      }
       if (!pkg.dependencies?.typescript && !pkg.devDependencies.typescript)
         pkg.devDependencies.typescript = '^5.6.3';
     }
@@ -92,7 +126,7 @@ export const webPreset: PresetHandler = {
         'allowBuilds:\n  esbuild: true\n',
         { dryRun, silent }
       );
-    setupTesting(ctx, hadVitestScript);
+    if (vitest) setupTesting(ctx, hadVitestScript);
     if (config.browser.playwright) setupBrowserTesting(targetDir, { dryRun, silent });
     if (config.docs.adr) setupAdr(targetDir, { dryRun, silent });
   }