@antomanc/aginit 0.1.0

package/src/cli/new.ts

@@ -0,0 +1,200 @@
+import path from 'node:path';
+import pc from 'picocolors';
+import { getDefaultConfig } from '../config/defaults.js';
+import {
+  AGINIT_CONFIG_FILENAME,
+  PresetType,
+  WebFramework,
+  PackageManager
+} from '../config/schema.js';
+import { getPreset } from '../presets/registry.js';
+import { setupGit } from '../adapters/git.js';
+import { setupAgentsMarkdown } from '../adapters/agents-md.js';
+import { installAllSkills } from '../adapters/skills.js';
+import { initGraft } from '../adapters/graft.js';
+import { ensureDir, writeJsonFile } from '../utils/fs.js';
+import {
+  readProjectConfig,
+  readPackageManifest,
+  validateConfig,
+  validateProjectName,
+  PRESETS,
+  FRAMEWORKS,
+  SUPPORTED_PACKAGE_MANAGERS
+} from '../config/validation.js';
+import { logger } from '../utils/logger.js';
+
+export interface NewProjectOptions {
+  preset?: PresetType;
+  framework?: WebFramework;
+  packageManager?: PackageManager;
+  specWorkflow?: boolean;
+  skills?: boolean;
+  graft?: boolean;
+  git?: boolean;
+  dryRun?: boolean;
+  targetDir?: string;
+  silent?: boolean;
+}
+
+export async function createProject(
+  projectName: string,
+  options: NewProjectOptions = {}
+): Promise<boolean> {
+  validateProjectName(projectName);
+  if (options.preset !== undefined && !PRESETS.includes(options.preset))
+    throw new Error('Invalid preset.');
+  if (options.framework !== undefined && !FRAMEWORKS.includes(options.framework))
+    throw new Error('Invalid framework.');
+  if (
+    options.packageManager !== undefined &&
+    !SUPPORTED_PACKAGE_MANAGERS.includes(options.packageManager)
+  )
+    throw new Error('Invalid package manager.');
+  const defaultDir =
+    projectName.startsWith('@') && projectName.includes('/')
+      ? projectName.split('/').pop()!
+      : projectName;
+  const targetDir = path.resolve(options.targetDir || path.join(process.cwd(), defaultDir));
+  const existingConfig = readProjectConfig(targetDir);
+  const manifest = readPackageManifest(targetDir); // Validate before creating or modifying anything.
+  const presetName = options.preset ?? existingConfig?.preset ?? 'generic';
+  const framework =
+    options.framework ?? (presetName === 'web' ? existingConfig?.framework : undefined);
+  if (presetName !== 'web' && framework && framework !== 'none' && framework !== 'existing')
+    throw new Error('A web framework requires --preset web.');
+  if (presetName === 'web' && framework === 'existing' && !manifest)
+    throw new Error(
+      'An existing web framework requires an existing package.json. Use --framework none for a new baseline.'
+    );
+  const packageManager = options.packageManager ?? existingConfig?.packageManager ?? 'pnpm';
+  const dryRun = !!options.dryRun;
+  const silent = !!options.silent;
+  const presetHandler = getPreset(presetName);
+  const defaults = getDefaultConfig(projectName, presetName, {
+    framework,
+    packageManager,
+    specWorkflow: options.specWorkflow
+  });
+  const config = validateConfig(
+    existingConfig
+      ? {
+          ...existingConfig,
+          name: projectName,
+          preset: presetName,
+          packageManager,
+          ...(presetName === 'web' ? { framework: framework ?? 'none' } : {}),
+          browser:
+            options.framework !== undefined || options.preset !== undefined
+              ? { ...existingConfig.browser, ...defaults.browser }
+              : existingConfig.browser,
+          skills:
+            options.specWorkflow !== undefined
+              ? {
+                  ...existingConfig.skills,
+                  workflow: defaults.skills.workflow,
+                  sources: existingConfig.skills.sources.map((source) =>
+                    source.package === 'mattpocock/skills'
+                      ? {
+                          ...source,
+                          skills: defaults.skills.sources.find((s) => s.package === source.package)!
+                            .skills
+                        }
+                      : source
+                  )
+                }
+              : existingConfig.skills
+        }
+      : defaults
+  );
+  if (presetName !== 'web') delete config.framework;
+  if (options.graft === false) config.codebase = { ...config.codebase, graft: false };
+  if (options.skills === false && !existingConfig) config.skills.sources = [];
+  if (!silent)
+    logger.banner(
+      `Aginit — ${projectName}`,
+      `Preset: ${presetName} | PM: ${packageManager} | Target: ${targetDir}${dryRun ? ' (DRY RUN)' : ''}`
+    );
+  let complete = true;
+
+  const totalSteps = 6;
+  let currentStep = 1;
+
+  // Scaffold into the clean directory before Git adds files that upstream tools reject.
+  if (!silent) logger.step(currentStep++, totalSteps, `Scaffolding preset: ${presetHandler.name}`);
+  ensureDir(targetDir, dryRun);
+  await presetHandler.scaffold({ targetDir, projectName, config, dryRun, silent: true });
+  if (!silent) logger.success(`Scaffolded ${presetHandler.name} structure`);
+
+  if (!silent) logger.step(currentStep++, totalSteps, 'Configuring Git');
+  if (options.git !== false) {
+    const gitOk = await setupGit(targetDir, { dryRun, silent: true });
+    complete &&= gitOk;
+    if (gitOk && !silent) logger.success('Git repository initialized and .gitignore configured');
+  }
+
+  // Step 3: Write declarative project config
+  if (!silent) logger.step(currentStep++, totalSteps, 'Writing declarative project configuration');
+  writeJsonFile(path.join(targetDir, AGINIT_CONFIG_FILENAME), config, {
+    overwrite: true,
+    dryRun,
+    silent
+  });
+  if (!silent) logger.success(`Wrote ${AGINIT_CONFIG_FILENAME}`);
+
+  // Step 4: Write or update AGENTS.md intake contract
+  if (!silent) logger.step(currentStep++, totalSteps, 'Generating AGENTS.md intake guidance');
+  setupAgentsMarkdown(targetDir, config, { dryRun, silent });
+  if (!silent) logger.success('Configured AGENTS.md');
+
+  // Step 5: Install skills via skills.sh engine
+  if (!silent) logger.step(currentStep++, totalSteps, 'Installing upstream skills via skills.sh');
+  if (options.skills !== false && config.skills.sources.length > 0) {
+    const { installed, failed } = await installAllSkills(targetDir, config.skills.sources, {
+      agents: [config.agents.primary, config.agents.secondary],
+      dryRun,
+      silent
+    });
+    complete &&= failed.length === 0;
+    if (!silent) {
+      if (installed.length > 0) {
+        logger.success(`Installed skills: ${installed.join(', ')}`);
+      }
+      if (failed.length > 0) {
+        logger.warn(`Failed installing: ${failed.join(', ')}`);
+      }
+    }
+  } else if (!silent) {
+    logger.dim('Skills installation skipped (--no-skills or empty configuration)');
+  }
+
+  // Step 6: Codebase intelligence (Graft)
+  if (!silent) logger.step(currentStep++, totalSteps, 'Configuring codebase intelligence');
+  if (config.codebase.graft && options.graft !== false) {
+    const graftOk = await initGraft(targetDir, { dryRun, silent });
+    complete &&= graftOk;
+    if (graftOk && !silent) {
+      logger.success('Graft context graph initialized');
+    }
+  } else if (!silent) {
+    logger.dim('Graft setup skipped (--no-graft or codebase.graft: false)');
+  }
+
+  if (!silent) {
+    console.log();
+    if (complete) logger.success(pc.bold(`Project "${projectName}" is ready for development!`));
+    else
+      logger.warn(
+        `Project "${projectName}" was scaffolded with incomplete integrations. Resolve the warnings above and rerun aginit init.`
+      );
+    console.log();
+    console.log('Next steps:');
+    console.log(pc.cyan(`  cd ${path.relative(process.cwd(), targetDir) || '.'}`));
+    console.log(pc.cyan(`  ${packageManager} install`));
+    console.log(pc.cyan('  Open the repository in T3 Code'));
+    console.log(pc.dim('  Prompt the agent: ') + pc.bold(pc.green('"bootstrap this project"')));
+    console.log();
+  }
+
+  return complete;
+}

package/src/cli/wizard.ts

@@ -0,0 +1,300 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { PresetType, WebFramework, PackageManager } from '../config/schema.js';
+import { validateProjectName, readProjectConfig } from '../config/validation.js';
+import { detectPackageManager } from '../adapters/package-manager.js';
+import { createProject } from './new.js';
+import { initCurrentDirectory } from './init.js';
+
+export function isInteractive(): boolean {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY && !process.env.CI);
+}
+
+function assertNotCancelled<T>(value: T | symbol): Exclude<T, symbol> {
+  if (p.isCancel(value)) {
+    p.cancel('Operation cancelled.');
+    process.exit(0);
+  }
+  return value as Exclude<T, symbol>;
+}
+
+export interface WizardNewAnswers {
+  projectName: string;
+  preset: PresetType;
+  framework: WebFramework;
+  packageManager: PackageManager;
+  specWorkflow: boolean;
+}
+
+export interface WizardInitAnswers {
+  preset: PresetType;
+  framework: WebFramework;
+  packageManager: PackageManager;
+  specWorkflow: boolean;
+}
+
+export async function promptNewProject(defaults?: {
+  projectName?: string;
+  preset?: PresetType;
+  framework?: WebFramework;
+  packageManager?: PackageManager;
+  specWorkflow?: boolean;
+}): Promise<WizardNewAnswers> {
+  let projectName: string = defaults?.projectName || '';
+  if (!projectName) {
+    const res = await p.text({
+      message: 'What is your project name?',
+      placeholder: 'my-ai-project',
+      validate: (val) => {
+        if (!val || val.trim().length === 0) return 'Project name is required';
+        try {
+          validateProjectName(val.trim());
+        } catch (error) {
+          return error instanceof Error ? error.message : 'Invalid project name';
+        }
+      }
+    });
+    projectName = String(assertNotCancelled(res)).trim();
+  }
+
+  let preset = defaults?.preset;
+  if (!preset) {
+    const res = await p.select({
+      message: 'Select a project preset:',
+      initialValue: 'web',
+      options: [
+        {
+          value: 'web',
+          label: 'Web Application',
+          hint: 'React, Next.js, Vite, or agnostic + Vitest/Playwright'
+        },
+        { value: 'cli', label: 'CLI Tool', hint: 'TypeScript, Commander, Picocolors + Vitest' },
+        {
+          value: 'generic',
+          label: 'Generic / Existing Codebase',
+          hint: 'Codebase graph + agent intake guide'
+        }
+      ]
+    });
+    preset = assertNotCancelled(res) as PresetType;
+  }
+
+  let framework: WebFramework = defaults?.framework || 'none';
+  if (preset === 'web' && defaults?.framework === undefined) {
+    const res = await p.select({
+      message: 'Choose a web framework:',
+      initialValue: 'none',
+      options: [
+        {
+          value: 'none',
+          label: 'Framework-agnostic (Recommended)',
+          hint: 'Clean TypeScript + Vitest, zero bundler lock-in'
+        },
+        {
+          value: 'vite',
+          label: 'Vite',
+          hint: 'Official Vite React-TS scaffolder + Playwright E2E'
+        },
+        { value: 'next', label: 'Next.js', hint: 'Official create-next-app + Playwright E2E' }
+      ]
+    });
+    framework = assertNotCancelled(res) as WebFramework;
+  }
+
+  let specWorkflow = defaults?.specWorkflow;
+  if (specWorkflow === undefined) {
+    const res = await p.select({
+      message: 'Select AI engineering workflow:',
+      initialValue: 'minimal',
+      options: [
+        {
+          value: 'minimal',
+          label: 'Standard Workflow (Recommended)',
+          hint: 'TDD, Code Review, Diagnosing Bugs'
+        },
+        {
+          value: 'spec',
+          label: 'Spec & Tickets Workflow',
+          hint: 'Adds to-spec, to-tickets, implement-spec'
+        }
+      ]
+    });
+    const selected = assertNotCancelled(res);
+    specWorkflow = selected === 'spec';
+  }
+
+  let packageManager = defaults?.packageManager;
+  if (!packageManager) {
+    const res = await p.select({
+      message: 'Select package manager:',
+      initialValue: 'pnpm',
+      options: [
+        {
+          value: 'pnpm',
+          label: 'pnpm (Recommended)',
+          hint: 'Fast, disk-efficient & compliant workspace'
+        },
+        { value: 'npm', label: 'npm', hint: 'Standard Node.js package manager' },
+        { value: 'yarn', label: 'yarn', hint: 'Yarn package manager' },
+        { value: 'bun', label: 'bun', hint: 'Fast all-in-one JavaScript runtime & toolkit' }
+      ]
+    });
+    packageManager = assertNotCancelled(res) as PackageManager;
+  }
+
+  return {
+    projectName,
+    preset,
+    framework,
+    packageManager,
+    specWorkflow
+  };
+}
+
+export async function promptInitProject(defaults?: {
+  targetDir?: string;
+  preset?: PresetType;
+  framework?: WebFramework;
+  packageManager?: PackageManager;
+  specWorkflow?: boolean;
+}): Promise<WizardInitAnswers> {
+  const targetDir = defaults?.targetDir || process.cwd();
+
+  let preset = defaults?.preset;
+  if (!preset) {
+    const res = await p.select({
+      message: 'Select project preset to configure in this directory:',
+      initialValue: 'web',
+      options: [
+        { value: 'web', label: 'Web Application', hint: 'Impeccable UI, agent-browser, Vitest' },
+        { value: 'cli', label: 'CLI Tool', hint: 'TypeScript, Vitest' },
+        {
+          value: 'generic',
+          label: 'Generic Repository',
+          hint: 'Codebase graph + agent intake guide'
+        }
+      ]
+    });
+    preset = assertNotCancelled(res) as PresetType;
+  }
+
+  let framework: WebFramework = defaults?.framework || 'existing';
+  if (preset === 'web' && defaults?.framework === undefined) {
+    const res = await p.select({
+      message: 'Select web framework setting:',
+      initialValue: 'existing',
+      options: [
+        {
+          value: 'existing',
+          label: 'Existing Web Setup (Recommended)',
+          hint: 'Preserve existing bundler and dependencies'
+        },
+        { value: 'none', label: 'Framework-agnostic', hint: 'Baseline TypeScript' },
+        { value: 'vite', label: 'Vite', hint: 'Vite React setup' },
+        { value: 'next', label: 'Next.js', hint: 'Next.js setup' }
+      ]
+    });
+    framework = assertNotCancelled(res) as WebFramework;
+  }
+
+  let specWorkflow = defaults?.specWorkflow;
+  if (specWorkflow === undefined) {
+    const res = await p.select({
+      message: 'Select AI engineering workflow:',
+      initialValue: 'minimal',
+      options: [
+        {
+          value: 'minimal',
+          label: 'Standard Workflow (Recommended)',
+          hint: 'TDD, Code Review, Diagnosing Bugs'
+        },
+        {
+          value: 'spec',
+          label: 'Spec & Tickets Workflow',
+          hint: 'Adds to-spec, to-tickets, implement-spec'
+        }
+      ]
+    });
+    const selected = assertNotCancelled(res);
+    specWorkflow = selected === 'spec';
+  }
+
+  // Auto-detect and preserve existing package manager without prompting
+  let packageManager = defaults?.packageManager;
+  if (!packageManager) {
+    const detected = detectPackageManager(targetDir);
+    if (detected) {
+      packageManager = detected;
+    } else {
+      const res = await p.select({
+        message: 'Select package manager for this project:',
+        initialValue: 'pnpm',
+        options: [
+          { value: 'pnpm', label: 'pnpm (Recommended)', hint: 'Fast, disk-efficient workspace' },
+          { value: 'npm', label: 'npm', hint: 'Standard Node.js package manager' },
+          { value: 'yarn', label: 'yarn', hint: 'Yarn package manager' },
+          { value: 'bun', label: 'bun', hint: 'Fast runtime and package manager' }
+        ]
+      });
+      packageManager = assertNotCancelled(res) as PackageManager;
+    }
+  }
+
+  return {
+    preset,
+    framework,
+    packageManager,
+    specWorkflow
+  };
+}
+
+export async function runInteractiveWizard(): Promise<void> {
+  p.intro(pc.bgCyan(pc.black(' aginit ')) + pc.dim(' — AI-First Project Bootstrap'));
+
+  const action = assertNotCancelled(
+    await p.select({
+      message: 'What would you like to do?',
+      initialValue: 'new',
+      options: [
+        {
+          value: 'new',
+          label: 'Create a brand new AI-first project',
+          hint: 'Scaffold in a new directory'
+        },
+        {
+          value: 'init',
+          label: 'Initialize AI capabilities in current directory',
+          hint: 'Add AGENTS.md, skills & Graft safely'
+        }
+      ]
+    })
+  );
+
+  let complete: boolean;
+  if (action === 'new') {
+    const answers = await promptNewProject();
+    p.outro(pc.cyan(`Scaffolding "${answers.projectName}"...`));
+    complete = await createProject(answers.projectName, {
+      preset: answers.preset,
+      framework: answers.framework,
+      packageManager: answers.packageManager,
+      specWorkflow: answers.specWorkflow
+    });
+  } else {
+    const saved = readProjectConfig(process.cwd());
+    if (saved) {
+      p.outro(pc.cyan('Configuring current directory using saved settings...'));
+      complete = await initCurrentDirectory();
+    } else {
+      const answers = await promptInitProject();
+      p.outro(pc.cyan('Configuring current directory...'));
+      complete = await initCurrentDirectory({
+        preset: answers.preset,
+        framework: answers.framework,
+        packageManager: answers.packageManager,
+        specWorkflow: answers.specWorkflow
+      });
+    }
+  }
+  if (!complete) process.exitCode = 1;
+}

package/src/config/defaults.ts

@@ -0,0 +1,137 @@
+import { AginitConfig, PresetType, WebFramework, PackageManager } from './schema.js';
+
+export interface DefaultConfigOptions {
+  framework?: WebFramework;
+  specWorkflow?: boolean;
+  packageManager?: PackageManager;
+}
+
+export function getDefaultConfig(
+  name: string,
+  preset: PresetType,
+  options: DefaultConfigOptions = {}
+): AginitConfig {
+  const specWorkflow = !!options.specWorkflow;
+  const packageManager = options.packageManager || 'pnpm';
+  const mattSkills = specWorkflow
+    ? ['tdd', 'code-review', 'diagnosing-bugs', 'to-spec', 'to-tickets', 'implement-spec']
+    : ['tdd', 'code-review', 'diagnosing-bugs'];
+
+  switch (preset) {
+    case 'web': {
+      const framework = options.framework || 'none';
+      const hasWebTarget = framework === 'vite' || framework === 'next';
+
+      return {
+        schemaVersion: '1.0.0',
+        name,
+        preset: 'web',
+        framework,
+        packageManager,
+        agents: {
+          primary: 'antigravity',
+          secondary: 'codex'
+        },
+        skills: {
+          workflow: specWorkflow ? 'spec' : 'minimal',
+          sources: [
+            {
+              package: 'mattpocock/skills',
+              skills: mattSkills
+            },
+            {
+              package: 'pbakaus/impeccable',
+              skills: ['impeccable']
+            },
+            {
+              package: 'vercel-labs/agent-browser',
+              skills: ['agent-browser']
+            }
+          ]
+        },
+        codebase: {
+          graft: true
+        },
+        browser: {
+          visualAgent: true,
+          playwright: hasWebTarget
+        },
+        docs: {
+          adr: true
+        },
+        github: {
+          ci: true
+        }
+      };
+    }
+
+    case 'cli':
+      return {
+        schemaVersion: '1.0.0',
+        name,
+        preset: 'cli',
+        packageManager,
+        agents: {
+          primary: 'antigravity',
+          secondary: 'codex'
+        },
+        skills: {
+          workflow: specWorkflow ? 'spec' : 'minimal',
+          sources: [
+            {
+              package: 'mattpocock/skills',
+              skills: mattSkills
+            }
+          ]
+        },
+        codebase: {
+          graft: true
+        },
+        browser: {
+          visualAgent: false,
+          playwright: false
+        },
+        docs: {
+          adr: true
+        },
+        github: {
+          ci: true
+        }
+      };
+
+    case 'generic':
+    default:
+      return {
+        schemaVersion: '1.0.0',
+        name,
+        preset: 'generic',
+        packageManager,
+        agents: {
+          primary: 'antigravity',
+          secondary: 'codex'
+        },
+        skills: {
+          workflow: specWorkflow ? 'spec' : 'minimal',
+          sources: [
+            {
+              package: 'mattpocock/skills',
+              skills: mattSkills
+            }
+          ]
+        },
+        codebase: {
+          graft: true
+        },
+        browser: {
+          visualAgent: false,
+          playwright: false
+        },
+        docs: {
+          adr: true
+        },
+        github: {
+          ci: false
+        }
+      };
+  }
+}

package/src/config/schema.ts

@@ -0,0 +1,44 @@
+export type PresetType = 'web' | 'cli' | 'generic';
+export type WebFramework = 'none' | 'vite' | 'next' | 'existing';
+export type PackageManager = 'pnpm' | 'npm' | 'yarn' | 'bun';
+
+export interface SkillSourceConfig {
+  package: string;
+  skills: string[];
+}
+
+export interface AginitConfig {
+  schemaVersion: string;
+  name: string;
+  preset: PresetType;
+  framework?: WebFramework;
+  packageManager?: PackageManager;
+  agents: {
+    primary: string;
+    secondary: string;
+  };
+  skills: {
+    workflow?: 'minimal' | 'spec';
+    sources: SkillSourceConfig[];
+  };
+  codebase: {
+    graft: boolean;
+  };
+  browser: {
+    visualAgent: boolean;
+    playwright: boolean;
+  };
+  docs: {
+    adr: boolean;
+  };
+  github: {
+    ci: boolean;
+  };
+}
+
+// Backward-compatible alias
+export type AIProjectConfig = AginitConfig;
+
+export const AGINIT_CONFIG_FILENAME = 'aginit.config.json';
+export const LEGACY_CONFIG_FILENAME = 'ai.config.json';
+export const AI_CONFIG_FILENAME = AGINIT_CONFIG_FILENAME;