diff --git a/README.md b/README.md index ee6cdae2..e5f0c6dc 100644 --- a/README.md +++ b/README.md @@ -313,6 +313,20 @@ skillkit context init # Initialize project context skillkit context sync # Sync context to agents ``` +### AI Instruction Generation (Primer) + +Generate AI instruction files for all 32 supported agents based on your codebase analysis: + +```bash +skillkit primer # Analyze codebase, generate for detected agents +skillkit primer --all-agents # Generate for all 32 agents +skillkit primer --agent claude-code,cursor # Specific agents only +skillkit primer --dry-run # Preview without writing files +skillkit primer --analyze-only # Only show codebase analysis +``` + +Inspired by [primer](https://github.com/pierceboggan/primer) but extended for all SkillKit agents. + ### Custom AI Sub-Agents ```bash diff --git a/apps/skillkit/src/cli.ts b/apps/skillkit/src/cli.ts index 40c1eb2a..80f0e8b2 100644 --- a/apps/skillkit/src/cli.ts +++ b/apps/skillkit/src/cli.ts @@ -48,7 +48,6 @@ import { AgentTranslateCommand, AgentSyncCommand, AgentValidateCommand, - // New commands (Phase 21) CheckCommand, FindCommand, ManifestCommand, @@ -57,6 +56,7 @@ import { ManifestRemoveCommand, ManifestInstallCommand, ManifestGenerateCommand, + PrimerCommand, } from '@skillkit/cli'; const __filename = fileURLToPath(import.meta.url); @@ -127,5 +127,6 @@ cli.register(ManifestAddCommand); cli.register(ManifestRemoveCommand); cli.register(ManifestInstallCommand); cli.register(ManifestGenerateCommand); +cli.register(PrimerCommand); cli.runExit(process.argv.slice(2)); diff --git a/packages/cli/src/commands/index.ts b/packages/cli/src/commands/index.ts index 2f5e1590..fe8f5ec1 100644 --- a/packages/cli/src/commands/index.ts +++ b/packages/cli/src/commands/index.ts @@ -53,3 +53,4 @@ export { ManifestInstallCommand, ManifestGenerateCommand, } from './manifest.js'; +export { PrimerCommand } from './primer.js'; diff --git a/packages/cli/src/commands/primer.ts b/packages/cli/src/commands/primer.ts new file mode 100644 index 00000000..186c35bf --- /dev/null +++ b/packages/cli/src/commands/primer.ts @@ -0,0 +1,363 @@ +import { Command, Option } from 'clipanion'; +import { resolve } from 'node:path'; +import chalk from 'chalk'; +import { + type AgentType, + AgentType as AgentTypeSchema, + generatePrimer, + analyzePrimer, + AGENT_CONFIG, +} from '@skillkit/core'; + +export class PrimerCommand extends Command { + static override paths = [['primer']]; + + static override usage = Command.Usage({ + description: 'Analyze codebase and generate AI instruction files for agents', + details: ` + The primer command analyzes your codebase to detect languages, frameworks, + patterns, and conventions, then generates customized instruction files + for AI coding agents. + + By default, it generates instructions for detected agents in your project. + Use --all-agents to generate for all 32 supported agents. + + Inspired by github.com/pierceboggan/primer but extended for all SkillKit agents. + `, + examples: [ + ['Generate for detected agents', '$0 primer'], + ['Generate for all 32 agents', '$0 primer --all-agents'], + ['Generate for specific agents', '$0 primer --agent claude-code,cursor,github-copilot'], + ['Custom output directory', '$0 primer --output ./instructions'], + ['Preview without writing files', '$0 primer --dry-run'], + ['Only show analysis', '$0 primer --analyze-only'], + ['Verbose output', '$0 primer --verbose'], + ], + }); + + agent = Option.String('--agent,-a', { + description: 'Comma-separated list of agents to generate for', + }); + + allAgents = Option.Boolean('--all-agents,-A', false, { + description: 'Generate for all 32 supported agents', + }); + + output = Option.String('--output,-o', { + description: 'Output directory for generated files', + }); + + dryRun = Option.Boolean('--dry-run,-n', false, { + description: 'Preview what would be generated without writing files', + }); + + analyzeOnly = Option.Boolean('--analyze-only', false, { + description: 'Only show codebase analysis, do not generate files', + }); + + verbose = Option.Boolean('--verbose,-v', false, { + description: 'Show detailed output', + }); + + includeExamples = Option.Boolean('--examples', false, { + description: 'Include code examples in generated instructions', + }); + + json = Option.Boolean('--json,-j', false, { + description: 'Output analysis in JSON format', + }); + + directory = Option.String('--dir,-d', { + description: 'Project directory to analyze (default: current directory)', + }); + + async execute(): Promise { + const projectPath = resolve(this.directory || process.cwd()); + + if (this.analyzeOnly) { + return this.runAnalysis(projectPath); + } + + return this.runGenerate(projectPath); + } + + private async runAnalysis(projectPath: string): Promise { + console.log(chalk.cyan('Analyzing codebase...\n')); + + try { + const analysis = analyzePrimer(projectPath); + + if (this.json) { + console.log(JSON.stringify(analysis, null, 2)); + return 0; + } + + this.printAnalysis(analysis); + return 0; + } catch (error) { + console.error(chalk.red('Analysis failed:'), error instanceof Error ? error.message : error); + return 1; + } + } + + private async runGenerate(projectPath: string): Promise { + const agents = this.parseAgents(); + + console.log(chalk.cyan('Analyzing codebase and generating AI instructions...\n')); + + try { + const result = generatePrimer(projectPath, { + projectPath, + agents, + allAgents: this.allAgents, + outputDir: this.output ? resolve(this.output) : undefined, + dryRun: this.dryRun, + verbose: this.verbose, + includeExamples: this.includeExamples, + }); + + if (this.verbose) { + this.printAnalysis(result.analysis); + console.log(); + } + + if (result.generated.length === 0) { + console.log(chalk.yellow('No instruction files generated.')); + if (result.errors.length > 0) { + for (const error of result.errors) { + console.log(chalk.red(` Error: ${error}`)); + } + } + return 1; + } + + console.log(chalk.bold('Generated Instruction Files:\n')); + + for (const instruction of result.generated) { + const status = this.dryRun ? chalk.yellow('(dry-run)') : chalk.green('created'); + console.log(` ${chalk.green('●')} ${chalk.bold(instruction.agent)}`); + console.log(` ${chalk.gray(instruction.filepath)} ${status}`); + } + + console.log(); + + if (result.warnings.length > 0) { + console.log(chalk.yellow('Warnings:')); + for (const warning of result.warnings) { + console.log(` ${chalk.yellow('⚠')} ${warning}`); + } + console.log(); + } + + if (result.errors.length > 0) { + console.log(chalk.red('Errors:')); + for (const error of result.errors) { + console.log(` ${chalk.red('✗')} ${error}`); + } + console.log(); + } + + const summary = this.dryRun + ? `Would generate ${result.generated.length} instruction file(s)` + : `Generated ${result.generated.length} instruction file(s)`; + + console.log(chalk.bold(summary)); + + if (this.dryRun) { + console.log(chalk.gray('\n(Dry run - no files were written)')); + } + + return result.success ? 0 : 1; + } catch (error) { + console.error(chalk.red('Generation failed:'), error instanceof Error ? error.message : error); + return 1; + } + } + + private parseAgents(): AgentType[] | undefined { + if (!this.agent) return undefined; + + const agents: AgentType[] = []; + const parts = this.agent.split(',').map(s => s.trim()); + + for (const part of parts) { + const result = AgentTypeSchema.safeParse(part); + if (result.success) { + agents.push(result.data); + } else { + console.warn(chalk.yellow(`Unknown agent: ${part}`)); + } + } + + return agents.length > 0 ? agents : undefined; + } + + private printAnalysis(analysis: ReturnType): void { + const { project, languages, packageManagers, stack, structure, conventions, ci, docker, buildCommands, importantFiles } = analysis; + + console.log(chalk.bold('Project Information')); + console.log(` Name: ${chalk.cyan(project.name)}`); + if (project.description) { + console.log(` Description: ${project.description}`); + } + if (project.type) { + console.log(` Type: ${project.type}`); + } + if (project.version) { + console.log(` Version: ${project.version}`); + } + console.log(); + + if (languages.length > 0) { + console.log(chalk.bold('Languages')); + for (const lang of languages) { + const version = lang.version ? ` (${lang.version})` : ''; + console.log(` ${chalk.green('●')} ${lang.name}${version}`); + } + console.log(); + } + + if (packageManagers.length > 0) { + console.log(chalk.bold('Package Managers')); + console.log(` ${chalk.cyan(packageManagers.join(', '))}`); + console.log(); + } + + if (stack.frameworks.length > 0) { + console.log(chalk.bold('Frameworks')); + for (const fw of stack.frameworks) { + const version = fw.version ? ` (${fw.version})` : ''; + console.log(` ${chalk.green('●')} ${fw.name}${version}`); + } + console.log(); + } + + if (stack.libraries.length > 0) { + console.log(chalk.bold('Libraries')); + for (const lib of stack.libraries.slice(0, 10)) { + const version = lib.version ? ` (${lib.version})` : ''; + console.log(` ${chalk.green('●')} ${lib.name}${version}`); + } + if (stack.libraries.length > 10) { + console.log(` ${chalk.gray(`...and ${stack.libraries.length - 10} more`)}`); + } + console.log(); + } + + if (stack.styling.length > 0) { + console.log(chalk.bold('Styling')); + for (const style of stack.styling) { + console.log(` ${chalk.green('●')} ${style.name}`); + } + console.log(); + } + + if (stack.testing.length > 0) { + console.log(chalk.bold('Testing')); + for (const test of stack.testing) { + console.log(` ${chalk.green('●')} ${test.name}`); + } + console.log(); + } + + if (stack.databases.length > 0) { + console.log(chalk.bold('Databases')); + for (const db of stack.databases) { + console.log(` ${chalk.green('●')} ${db.name}`); + } + console.log(); + } + + if (structure) { + console.log(chalk.bold('Project Structure')); + if (structure.type) { + console.log(` Type: ${structure.type}`); + } + if (structure.srcDir) { + console.log(` Source: ${structure.srcDir}/`); + } + if (structure.testDir) { + console.log(` Tests: ${structure.testDir}/`); + } + if (structure.hasWorkspaces) { + console.log(` Monorepo: Yes`); + if (structure.workspaces) { + console.log(` Workspaces: ${structure.workspaces.join(', ')}`); + } + } + console.log(); + } + + if (conventions && Object.keys(conventions).some(k => conventions[k as keyof typeof conventions] !== undefined)) { + console.log(chalk.bold('Code Conventions')); + if (conventions.indentation) { + console.log(` Indentation: ${conventions.indentation}`); + } + if (conventions.quotes) { + console.log(` Quotes: ${conventions.quotes}`); + } + if (conventions.semicolons !== undefined) { + console.log(` Semicolons: ${conventions.semicolons ? 'yes' : 'no'}`); + } + if (conventions.trailingCommas) { + console.log(` Trailing Commas: ${conventions.trailingCommas}`); + } + console.log(); + } + + if (ci && ci.hasCI) { + console.log(chalk.bold('CI/CD')); + console.log(` Provider: ${ci.provider}`); + if (ci.hasCD) { + console.log(` Deployment: Yes`); + } + console.log(); + } + + if (docker && (docker.hasDockerfile || docker.hasCompose)) { + console.log(chalk.bold('Docker')); + if (docker.hasDockerfile) { + console.log(` Dockerfile: Yes`); + if (docker.baseImage) { + console.log(` Base Image: ${docker.baseImage}`); + } + } + if (docker.hasCompose) { + console.log(` Docker Compose: Yes`); + } + console.log(); + } + + if (buildCommands && Object.keys(buildCommands).some(k => buildCommands[k as keyof typeof buildCommands])) { + console.log(chalk.bold('Build Commands')); + if (buildCommands.install) { + console.log(` Install: ${chalk.gray(buildCommands.install)}`); + } + if (buildCommands.dev) { + console.log(` Dev: ${chalk.gray(buildCommands.dev)}`); + } + if (buildCommands.build) { + console.log(` Build: ${chalk.gray(buildCommands.build)}`); + } + if (buildCommands.test) { + console.log(` Test: ${chalk.gray(buildCommands.test)}`); + } + console.log(); + } + + if (importantFiles.length > 0 && this.verbose) { + console.log(chalk.bold('Important Files')); + for (const file of importantFiles.slice(0, 15)) { + console.log(` ${chalk.gray(file)}`); + } + if (importantFiles.length > 15) { + console.log(` ${chalk.gray(`...and ${importantFiles.length - 15} more`)}`); + } + console.log(); + } + + console.log(chalk.bold('Available Agents')); + console.log(chalk.gray(` Use --all-agents to generate for all ${Object.keys(AGENT_CONFIG).length} agents`)); + console.log(chalk.gray(` Use --agent to generate for specific agents`)); + } +} diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts index d6f17901..b9353aec 100644 --- a/packages/core/src/index.ts +++ b/packages/core/src/index.ts @@ -77,3 +77,6 @@ export * from './skill-translator.js'; export * from './manifest/index.js'; export * from './quality/index.js'; + +// Primer (AI Instruction Generator) +export * from './primer/index.js'; diff --git a/packages/core/src/primer/__tests__/primer.test.ts b/packages/core/src/primer/__tests__/primer.test.ts new file mode 100644 index 00000000..6779aabd --- /dev/null +++ b/packages/core/src/primer/__tests__/primer.test.ts @@ -0,0 +1,198 @@ +import { describe, it, expect, beforeAll, afterAll } from 'vitest'; +import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs'; +import { join } from 'node:path'; +import { tmpdir } from 'node:os'; +import { PrimerAnalyzer, analyzePrimer } from '../analyzer.js'; +import { PrimerGenerator, generatePrimer } from '../generator.js'; + +const TEST_DIR = join(tmpdir(), 'skillkit-primer-test-' + Date.now()); + +describe('Primer', () => { + beforeAll(() => { + mkdirSync(TEST_DIR, { recursive: true }); + + writeFileSync( + join(TEST_DIR, 'package.json'), + JSON.stringify({ + name: 'test-project', + version: '1.0.0', + description: 'A test project', + scripts: { + build: 'tsc', + test: 'vitest', + lint: 'eslint .', + }, + dependencies: { + react: '^18.0.0', + next: '^14.0.0', + }, + devDependencies: { + typescript: '^5.0.0', + tailwindcss: '^3.0.0', + vitest: '^1.0.0', + eslint: '^8.0.0', + prettier: '^3.0.0', + }, + }) + ); + + writeFileSync(join(TEST_DIR, 'tsconfig.json'), JSON.stringify({ compilerOptions: {} })); + + mkdirSync(join(TEST_DIR, 'src'), { recursive: true }); + writeFileSync(join(TEST_DIR, 'src', 'index.ts'), 'export const hello = "world";'); + + mkdirSync(join(TEST_DIR, '.github', 'workflows'), { recursive: true }); + writeFileSync(join(TEST_DIR, '.github', 'workflows', 'ci.yml'), 'name: CI'); + + writeFileSync(join(TEST_DIR, 'pnpm-lock.yaml'), ''); + }); + + afterAll(() => { + if (existsSync(TEST_DIR)) { + rmSync(TEST_DIR, { recursive: true, force: true }); + } + }); + + describe('PrimerAnalyzer', () => { + it('should detect project info', () => { + const analyzer = new PrimerAnalyzer(TEST_DIR); + const analysis = analyzer.analyze(); + + expect(analysis.project.name).toBe('test-project'); + expect(analysis.project.version).toBe('1.0.0'); + expect(analysis.project.description).toBe('A test project'); + }); + + it('should detect languages', () => { + const analysis = analyzePrimer(TEST_DIR); + + const typescript = analysis.languages.find(l => l.name === 'typescript'); + expect(typescript).toBeDefined(); + expect(typescript?.version).toBe('5.0.0'); + }); + + it('should detect package managers', () => { + const analysis = analyzePrimer(TEST_DIR); + + expect(analysis.packageManagers).toContain('pnpm'); + }); + + it('should detect frameworks', () => { + const analysis = analyzePrimer(TEST_DIR); + + const react = analysis.stack.frameworks.find(f => f.name === 'react'); + const nextjs = analysis.stack.frameworks.find(f => f.name === 'nextjs'); + + expect(react).toBeDefined(); + expect(nextjs).toBeDefined(); + }); + + it('should detect styling', () => { + const analysis = analyzePrimer(TEST_DIR); + + const tailwind = analysis.stack.styling.find(s => s.name === 'tailwindcss'); + expect(tailwind).toBeDefined(); + }); + + it('should detect testing', () => { + const analysis = analyzePrimer(TEST_DIR); + + const vitest = analysis.stack.testing.find(t => t.name === 'vitest'); + expect(vitest).toBeDefined(); + }); + + it('should detect tools', () => { + const analysis = analyzePrimer(TEST_DIR); + + const eslint = analysis.stack.tools.find(t => t.name === 'eslint'); + const prettier = analysis.stack.tools.find(t => t.name === 'prettier'); + + expect(eslint).toBeDefined(); + expect(prettier).toBeDefined(); + }); + + it('should detect CI config', () => { + const analysis = analyzePrimer(TEST_DIR); + + expect(analysis.ci?.hasCI).toBe(true); + expect(analysis.ci?.provider).toBe('github-actions'); + }); + + it('should detect project structure', () => { + const analysis = analyzePrimer(TEST_DIR); + + expect(analysis.structure?.type).toBe('src-based'); + expect(analysis.structure?.srcDir).toBe('src'); + }); + + it('should extract build commands', () => { + const analysis = analyzePrimer(TEST_DIR); + + expect(analysis.buildCommands?.build).toBe('pnpm build'); + expect(analysis.buildCommands?.test).toBe('pnpm test'); + expect(analysis.buildCommands?.lint).toBe('pnpm lint'); + }); + }); + + describe('PrimerGenerator', () => { + it('should generate instruction files for detected agents', () => { + const result = generatePrimer(TEST_DIR, { dryRun: true }); + + expect(result.success).toBe(true); + expect(result.generated.length).toBeGreaterThan(0); + expect(result.errors.length).toBe(0); + }); + + it('should generate for specific agents', () => { + const result = generatePrimer(TEST_DIR, { + agents: ['claude-code', 'cursor'], + dryRun: true, + }); + + expect(result.success).toBe(true); + expect(result.generated.length).toBe(2); + + const agents = result.generated.map(g => g.agent); + expect(agents).toContain('claude-code'); + expect(agents).toContain('cursor'); + }); + + it('should analyze only when requested', () => { + const result = generatePrimer(TEST_DIR, { analyzeOnly: true }); + + expect(result.success).toBe(true); + expect(result.generated.length).toBe(0); + expect(result.analysis).toBeDefined(); + expect(result.analysis.project.name).toBe('test-project'); + }); + + it('should generate content with correct sections', () => { + const result = generatePrimer(TEST_DIR, { + agents: ['claude-code'], + dryRun: true, + }); + + expect(result.success).toBe(true); + const instruction = result.generated[0]; + + expect(instruction.content).toContain('# test-project'); + expect(instruction.content).toContain('## Technology Stack'); + expect(instruction.content).toContain('## Development Commands'); + expect(instruction.content).toContain('## Development Guidelines'); + }); + + it('should respect output directory option', () => { + const outputDir = join(TEST_DIR, 'output'); + mkdirSync(outputDir, { recursive: true }); + + const result = generatePrimer(TEST_DIR, { + agents: ['claude-code'], + outputDir, + dryRun: true, + }); + + expect(result.success).toBe(true); + expect(result.generated[0].filepath).toContain('output'); + }); + }); +}); diff --git a/packages/core/src/primer/analyzer.ts b/packages/core/src/primer/analyzer.ts new file mode 100644 index 00000000..be46171f --- /dev/null +++ b/packages/core/src/primer/analyzer.ts @@ -0,0 +1,650 @@ +import { existsSync, readFileSync, readdirSync } from 'node:fs'; +import { join, basename } from 'node:path'; +import type { + PrimerAnalysis, + PackageManager, + CodeConvention, + ProjectStructure, + CIConfig, + EnvConfig, + DockerConfig, +} from './types.js'; +import { ProjectDetector } from '../context/detector.js'; +import type { Detection } from '../context/types.js'; + +const PACKAGE_MANAGER_FILES: Record = { + 'package-lock.json': 'npm', + 'pnpm-lock.yaml': 'pnpm', + 'yarn.lock': 'yarn', + 'bun.lockb': 'bun', + 'requirements.txt': 'pip', + 'Pipfile.lock': 'pip', + 'poetry.lock': 'poetry', + 'uv.lock': 'uv', + 'Cargo.lock': 'cargo', + 'go.sum': 'go', + 'pom.xml': 'maven', + 'build.gradle': 'gradle', + 'build.gradle.kts': 'gradle', + 'composer.lock': 'composer', + 'Gemfile.lock': 'bundler', + 'Podfile.lock': 'cocoapods', + 'Package.resolved': 'swift-package-manager', + 'packages.lock.json': 'nuget', +}; + +const CI_CONFIG_FILES: Record = { + '.github/workflows': 'github-actions', + '.gitlab-ci.yml': 'gitlab-ci', + '.circleci/config.yml': 'circleci', + 'Jenkinsfile': 'jenkins', + '.travis.yml': 'travis', + 'azure-pipelines.yml': 'azure-pipelines', +}; + +const IMPORTANT_CONFIG_FILES = [ + 'package.json', + 'tsconfig.json', + 'pyproject.toml', + 'Cargo.toml', + 'go.mod', + '.eslintrc.js', + '.eslintrc.json', + 'eslint.config.js', + '.prettierrc', + 'prettier.config.js', + 'biome.json', + 'tailwind.config.js', + 'tailwind.config.ts', + 'vite.config.ts', + 'next.config.js', + 'next.config.mjs', + 'webpack.config.js', + 'rollup.config.js', + 'turbo.json', + 'nx.json', + 'jest.config.js', + 'vitest.config.ts', + 'playwright.config.ts', + '.env.example', + 'docker-compose.yml', + 'Dockerfile', +]; + +export class PrimerAnalyzer { + private projectPath: string; + private packageJson: Record | null = null; + private files: Set = new Set(); + + constructor(projectPath: string) { + this.projectPath = projectPath; + } + + analyze(): PrimerAnalysis { + this.loadPackageJson(); + this.scanFiles(); + + const detector = new ProjectDetector(this.projectPath); + const stack = detector.analyze(); + const patterns = detector.detectPatterns(); + + const analysis: PrimerAnalysis = { + project: this.getProjectInfo(), + languages: this.detectLanguages(), + packageManagers: this.detectPackageManagers(), + stack, + patterns, + structure: this.detectProjectStructure(), + conventions: this.detectCodeConventions(), + ci: this.detectCIConfig(), + env: this.detectEnvConfig(), + docker: this.detectDockerConfig(), + buildCommands: this.extractBuildCommands(), + importantFiles: this.findImportantFiles(), + codebaseSize: this.estimateCodebaseSize(), + }; + + return analysis; + } + + private loadPackageJson(): void { + const packageJsonPath = join(this.projectPath, 'package.json'); + if (existsSync(packageJsonPath)) { + try { + const content = readFileSync(packageJsonPath, 'utf-8'); + this.packageJson = JSON.parse(content); + } catch { + this.packageJson = null; + } + } + } + + private scanFiles(maxDepth = 3): void { + const scan = (dir: string, depth: number) => { + if (depth > maxDepth) return; + try { + const entries = readdirSync(dir, { withFileTypes: true }); + for (const entry of entries) { + const relativePath = join(dir, entry.name).replace(this.projectPath + '/', ''); + if (entry.name.startsWith('.') && entry.name !== '.github' && entry.name !== '.env.example') { + if (!entry.isDirectory()) { + this.files.add(relativePath); + } + continue; + } + if (entry.name === 'node_modules' || entry.name === 'dist' || entry.name === 'build' || entry.name === '.git') { + continue; + } + this.files.add(relativePath); + if (entry.isDirectory()) { + scan(join(dir, entry.name), depth + 1); + } + } + } catch { + // Ignore permission errors + } + }; + scan(this.projectPath, 0); + } + + private getProjectInfo(): PrimerAnalysis['project'] { + const info: PrimerAnalysis['project'] = { + name: basename(this.projectPath), + }; + + if (this.packageJson) { + if (typeof this.packageJson.name === 'string') { + info.name = this.packageJson.name; + } + if (typeof this.packageJson.description === 'string') { + info.description = this.packageJson.description; + } + if (typeof this.packageJson.version === 'string') { + info.version = this.packageJson.version; + } + if (typeof this.packageJson.license === 'string') { + info.license = this.packageJson.license; + } + const repo = this.packageJson.repository; + if (typeof repo === 'string') { + info.repository = repo; + } else if (repo && typeof repo === 'object' && 'url' in repo) { + info.repository = String(repo.url); + } + } + + const pyprojectPath = join(this.projectPath, 'pyproject.toml'); + if (!this.packageJson && existsSync(pyprojectPath)) { + try { + const content = readFileSync(pyprojectPath, 'utf-8'); + const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/); + const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/); + const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/); + if (nameMatch) info.name = nameMatch[1]; + if (versionMatch) info.version = versionMatch[1]; + if (descMatch) info.description = descMatch[1]; + } catch { + // Ignore + } + } + + const cargoPath = join(this.projectPath, 'Cargo.toml'); + if (!this.packageJson && existsSync(cargoPath)) { + try { + const content = readFileSync(cargoPath, 'utf-8'); + const nameMatch = content.match(/name\s*=\s*["']([^"']+)["']/); + const versionMatch = content.match(/version\s*=\s*["']([^"']+)["']/); + const descMatch = content.match(/description\s*=\s*["']([^"']+)["']/); + if (nameMatch) info.name = nameMatch[1]; + if (versionMatch) info.version = versionMatch[1]; + if (descMatch) info.description = descMatch[1]; + } catch { + // Ignore + } + } + + const detector = new ProjectDetector(this.projectPath); + info.type = detector.detectProjectType(); + + return info; + } + + private detectLanguages(): Detection[] { + const languages: Detection[] = []; + + if (this.hasFile('tsconfig.json')) { + const version = this.getDepVersion('typescript'); + languages.push({ + name: 'typescript', + version, + confidence: 100, + source: 'tsconfig.json', + }); + } + + if (this.packageJson && !this.hasFile('tsconfig.json')) { + languages.push({ + name: 'javascript', + confidence: 90, + source: 'package.json', + }); + } + + if (this.hasFile('pyproject.toml') || this.hasFile('requirements.txt') || this.hasFile('setup.py')) { + languages.push({ + name: 'python', + confidence: 100, + source: 'pyproject.toml', + }); + } + + if (this.hasFile('go.mod')) { + languages.push({ + name: 'go', + confidence: 100, + source: 'go.mod', + }); + } + + if (this.hasFile('Cargo.toml')) { + languages.push({ + name: 'rust', + confidence: 100, + source: 'Cargo.toml', + }); + } + + if (this.hasFile('pom.xml') || this.hasFile('build.gradle') || this.hasFile('build.gradle.kts')) { + languages.push({ + name: 'java', + confidence: 100, + source: 'pom.xml', + }); + } + + if (this.hasFile('Package.swift')) { + languages.push({ + name: 'swift', + confidence: 100, + source: 'Package.swift', + }); + } + + if (this.hasFile('Gemfile')) { + languages.push({ + name: 'ruby', + confidence: 100, + source: 'Gemfile', + }); + } + + if (this.hasFile('composer.json')) { + languages.push({ + name: 'php', + confidence: 100, + source: 'composer.json', + }); + } + + return languages; + } + + private detectPackageManagers(): string[] { + const managers: Set = new Set(); + + for (const [file, manager] of Object.entries(PACKAGE_MANAGER_FILES)) { + if (this.hasFile(file)) { + managers.add(manager); + } + } + + if (this.packageJson) { + const packageManager = this.packageJson.packageManager; + if (typeof packageManager === 'string') { + const match = packageManager.match(/^(npm|pnpm|yarn|bun)@/); + if (match) { + managers.add(match[1]); + } + } + } + + return Array.from(managers); + } + + private detectProjectStructure(): ProjectStructure { + const structure: ProjectStructure = { + hasWorkspaces: false, + }; + + if (this.hasFile('src')) { + structure.type = 'src-based'; + structure.srcDir = 'src'; + } else if (this.hasFile('packages') || this.hasFile('apps')) { + structure.type = 'monorepo'; + } else if (this.hasFile('lib')) { + structure.type = 'src-based'; + structure.srcDir = 'lib'; + } else { + structure.type = 'flat'; + } + + if (this.hasFile('tests') || this.hasFile('test') || this.hasFile('__tests__')) { + structure.testDir = this.hasFile('tests') ? 'tests' : this.hasFile('test') ? 'test' : '__tests__'; + } + + if (this.hasFile('docs') || this.hasFile('documentation')) { + structure.docsDir = this.hasFile('docs') ? 'docs' : 'documentation'; + } + + if (this.packageJson) { + const workspaces = this.packageJson.workspaces; + if (Array.isArray(workspaces)) { + structure.hasWorkspaces = true; + structure.workspaces = workspaces.filter(w => typeof w === 'string') as string[]; + structure.type = 'monorepo'; + } else if (workspaces && typeof workspaces === 'object' && 'packages' in workspaces) { + structure.hasWorkspaces = true; + structure.workspaces = (workspaces.packages as string[]) || []; + structure.type = 'monorepo'; + } + } + + if (this.hasFile('pnpm-workspace.yaml')) { + structure.hasWorkspaces = true; + structure.type = 'monorepo'; + } + + if (this.hasFile('turbo.json') || this.hasFile('nx.json')) { + structure.type = 'monorepo'; + } + + return structure; + } + + private detectCodeConventions(): CodeConvention { + const conventions: CodeConvention = {}; + + const prettierConfig = this.readConfigFile([ + '.prettierrc', + '.prettierrc.json', + 'prettier.config.js', + ]); + + const biomeConfig = this.readConfigFile(['biome.json']); + + if (prettierConfig) { + try { + const config = typeof prettierConfig === 'string' ? JSON.parse(prettierConfig) : prettierConfig; + if ('semi' in config) conventions.semicolons = config.semi; + if ('singleQuote' in config) conventions.quotes = config.singleQuote ? 'single' : 'double'; + if ('tabWidth' in config) { + conventions.indentation = config.useTabs ? 'tabs' : `spaces-${config.tabWidth}` as 'spaces-2' | 'spaces-4'; + } + if ('trailingComma' in config) conventions.trailingCommas = config.trailingComma; + if ('printWidth' in config) conventions.maxLineLength = config.printWidth; + } catch { + // Ignore parse errors + } + } + + if (biomeConfig) { + try { + const config = typeof biomeConfig === 'string' ? JSON.parse(biomeConfig) : biomeConfig; + const formatter = config.formatter || {}; + const js = config.javascript?.formatter || {}; + if (formatter.indentStyle) conventions.indentation = formatter.indentStyle === 'tab' ? 'tabs' : 'spaces-2'; + if (formatter.lineWidth) conventions.maxLineLength = formatter.lineWidth; + if (js.quoteStyle) conventions.quotes = js.quoteStyle; + if (js.semicolons) conventions.semicolons = js.semicolons !== 'asNeeded'; + if (js.trailingCommas) conventions.trailingCommas = js.trailingCommas; + } catch { + // Ignore parse errors + } + } + + if (this.hasFile('tsconfig.json')) { + try { + const tsconfigPath = join(this.projectPath, 'tsconfig.json'); + const content = readFileSync(tsconfigPath, 'utf-8'); + const tsconfig = JSON.parse(content.replace(/\/\/.*$/gm, '').replace(/,\s*}/g, '}')); + const paths = tsconfig.compilerOptions?.paths; + if (paths && Object.keys(paths).some(k => k.startsWith('@'))) { + conventions.namingStyle = 'camelCase'; + } + } catch { + // Ignore + } + } + + return conventions; + } + + private detectCIConfig(): CIConfig { + const ci: CIConfig = { + hasCI: false, + hasCD: false, + }; + + for (const [file, provider] of Object.entries(CI_CONFIG_FILES)) { + if (this.hasFile(file)) { + ci.hasCI = true; + ci.provider = provider; + ci.configFile = file; + break; + } + } + + if (this.hasFile('.github/workflows')) { + ci.hasCI = true; + ci.provider = 'github-actions'; + ci.configFile = '.github/workflows'; + + try { + const workflowsDir = join(this.projectPath, '.github/workflows'); + const workflows = readdirSync(workflowsDir); + const deployWorkflows = workflows.filter(f => + f.includes('deploy') || f.includes('release') || f.includes('publish') + ); + if (deployWorkflows.length > 0) { + ci.hasCD = true; + } + } catch { + // Ignore + } + } + + return ci; + } + + private detectEnvConfig(): EnvConfig { + const env: EnvConfig = { + hasEnvFile: false, + hasEnvExample: false, + }; + + env.hasEnvFile = this.hasFile('.env'); + env.hasEnvExample = this.hasFile('.env.example') || this.hasFile('.env.template') || this.hasFile('.env.sample'); + + if (env.hasEnvExample) { + const envExamplePath = join( + this.projectPath, + this.hasFile('.env.example') ? '.env.example' : this.hasFile('.env.template') ? '.env.template' : '.env.sample' + ); + try { + const content = readFileSync(envExamplePath, 'utf-8'); + const variables = content + .split('\n') + .filter(line => line.trim() && !line.startsWith('#')) + .map(line => line.split('=')[0].trim()) + .filter(v => v); + env.envVariables = variables; + } catch { + // Ignore + } + } + + return env; + } + + private detectDockerConfig(): DockerConfig { + const docker: DockerConfig = { + hasDockerfile: false, + hasCompose: false, + }; + + docker.hasDockerfile = this.hasFile('Dockerfile'); + docker.hasCompose = this.hasFile('docker-compose.yml') || this.hasFile('docker-compose.yaml') || this.hasFile('compose.yml'); + + if (docker.hasDockerfile) { + try { + const dockerfilePath = join(this.projectPath, 'Dockerfile'); + const content = readFileSync(dockerfilePath, 'utf-8'); + const fromMatch = content.match(/^FROM\s+(\S+)/m); + if (fromMatch) { + docker.baseImage = fromMatch[1]; + } + } catch { + // Ignore + } + } + + return docker; + } + + private extractBuildCommands(): PrimerAnalysis['buildCommands'] { + const commands: PrimerAnalysis['buildCommands'] = {}; + + if (this.packageJson && this.packageJson.scripts) { + const scripts = this.packageJson.scripts as Record; + if (scripts.build) commands.build = this.getRunCommand('build'); + if (scripts.test) commands.test = this.getRunCommand('test'); + if (scripts.lint) commands.lint = this.getRunCommand('lint'); + if (scripts.format) commands.format = this.getRunCommand('format'); + if (scripts.dev) commands.dev = this.getRunCommand('dev'); + if (scripts.start) commands.start = this.getRunCommand('start'); + } + + const packageManagers = this.detectPackageManagers(); + + if (!commands.install) { + if (packageManagers.includes('pnpm')) { + commands.install = 'pnpm install'; + } else if (packageManagers.includes('yarn')) { + commands.install = 'yarn install'; + } else if (packageManagers.includes('bun')) { + commands.install = 'bun install'; + } else if (packageManagers.includes('npm')) { + commands.install = 'npm install'; + } else if (packageManagers.includes('pip') || packageManagers.includes('poetry') || packageManagers.includes('uv')) { + if (packageManagers.includes('poetry')) { + commands.install = 'poetry install'; + } else if (packageManagers.includes('uv')) { + commands.install = 'uv sync'; + } else { + commands.install = 'pip install -r requirements.txt'; + } + } else if (packageManagers.includes('cargo')) { + commands.install = 'cargo build'; + } else if (packageManagers.includes('go')) { + commands.install = 'go mod download'; + } + } + + return commands; + } + + private findImportantFiles(): string[] { + const important: string[] = []; + + for (const file of IMPORTANT_CONFIG_FILES) { + if (this.hasFile(file)) { + important.push(file); + } + } + + if (this.hasFile('README.md')) { + important.push('README.md'); + } + + if (this.hasFile('CONTRIBUTING.md')) { + important.push('CONTRIBUTING.md'); + } + + if (this.hasFile('LICENSE') || this.hasFile('LICENSE.md')) { + important.push(this.hasFile('LICENSE') ? 'LICENSE' : 'LICENSE.md'); + } + + return important; + } + + private estimateCodebaseSize(): PrimerAnalysis['codebaseSize'] { + let files = 0; + let directories = 0; + + for (const file of this.files) { + if (file.includes('/')) { + directories++; + } + files++; + } + + return { + files, + directories: Math.floor(directories / 3), + }; + } + + private hasFile(name: string): boolean { + if (name.includes('*')) { + const regex = new RegExp(name.replace(/\*/g, '.*')); + for (const file of this.files) { + if (regex.test(file)) return true; + } + return false; + } + return this.files.has(name) || existsSync(join(this.projectPath, name)); + } + + private getDepVersion(dep: string): string | undefined { + if (!this.packageJson) return undefined; + const deps = this.packageJson.dependencies as Record | undefined; + const devDeps = this.packageJson.devDependencies as Record | undefined; + const version = deps?.[dep] || devDeps?.[dep]; + return version?.replace(/^[\^~>=<]+/, ''); + } + + private getRunCommand(script: string): string { + const packageManagers = this.detectPackageManagers(); + if (packageManagers.includes('pnpm')) { + return `pnpm ${script}`; + } else if (packageManagers.includes('yarn')) { + return `yarn ${script}`; + } else if (packageManagers.includes('bun')) { + return `bun run ${script}`; + } + return `npm run ${script}`; + } + + private readConfigFile(files: string[]): unknown | null { + for (const file of files) { + const filePath = join(this.projectPath, file); + if (existsSync(filePath)) { + try { + const content = readFileSync(filePath, 'utf-8'); + if (file.endsWith('.json')) { + return JSON.parse(content); + } + return content; + } catch { + // Ignore + } + } + } + return null; + } +} + +export function analyzePrimer(projectPath: string): PrimerAnalysis { + const analyzer = new PrimerAnalyzer(projectPath); + return analyzer.analyze(); +} diff --git a/packages/core/src/primer/generator.ts b/packages/core/src/primer/generator.ts new file mode 100644 index 00000000..32f4a41c --- /dev/null +++ b/packages/core/src/primer/generator.ts @@ -0,0 +1,571 @@ +import { existsSync, mkdirSync, writeFileSync } from 'node:fs'; +import { join, dirname } from 'node:path'; +import type { AgentType } from '../types.js'; +import { AGENT_CONFIG, type AgentDirectoryConfig } from '../agent-config.js'; +import type { + PrimerAnalysis, + PrimerOptions, + PrimerResult, + GeneratedInstruction, + AgentInstructionTemplate, +} from './types.js'; +import { AGENT_INSTRUCTION_TEMPLATES } from './types.js'; +import { analyzePrimer } from './analyzer.js'; + +const ALL_AGENTS: AgentType[] = [ + 'claude-code', + 'cursor', + 'codex', + 'gemini-cli', + 'opencode', + 'antigravity', + 'amp', + 'clawdbot', + 'droid', + 'github-copilot', + 'goose', + 'kilo', + 'kiro-cli', + 'roo', + 'trae', + 'windsurf', + 'universal', + 'cline', + 'codebuddy', + 'commandcode', + 'continue', + 'crush', + 'factory', + 'mcpjam', + 'mux', + 'neovate', + 'openhands', + 'pi', + 'qoder', + 'qwen', + 'vercel', + 'zencoder', +]; + +export class PrimerGenerator { + private projectPath: string; + private options: PrimerOptions; + private analysis: PrimerAnalysis | null = null; + + constructor(projectPath: string, options: PrimerOptions = {}) { + this.projectPath = projectPath; + this.options = options; + } + + generate(): PrimerResult { + const warnings: string[] = []; + const errors: string[] = []; + const generated: GeneratedInstruction[] = []; + + this.analysis = analyzePrimer(this.projectPath); + + if (this.options.analyzeOnly) { + return { + success: true, + analysis: this.analysis, + generated: [], + warnings, + errors, + }; + } + + const targetAgents = this.getTargetAgents(); + + for (const agent of targetAgents) { + try { + const instruction = this.generateForAgent(agent); + if (instruction) { + if (!this.options.dryRun) { + this.writeInstruction(instruction); + } + generated.push(instruction); + } + } catch (error) { + const message = error instanceof Error ? error.message : String(error); + errors.push(`Failed to generate for ${agent}: ${message}`); + } + } + + return { + success: errors.length === 0, + analysis: this.analysis, + generated, + warnings, + errors, + }; + } + + private getTargetAgents(): AgentType[] { + if (this.options.allAgents) { + return ALL_AGENTS; + } + + if (this.options.agents && this.options.agents.length > 0) { + return this.options.agents; + } + + return this.detectInstalledAgents(); + } + + private detectInstalledAgents(): AgentType[] { + const detected: AgentType[] = []; + + for (const [agent, config] of Object.entries(AGENT_CONFIG)) { + const configPath = join(this.projectPath, config.configFile); + const skillsPath = join(this.projectPath, config.skillsDir); + + if (existsSync(configPath) || existsSync(skillsPath)) { + detected.push(agent as AgentType); + } + + if (config.altSkillsDirs) { + for (const altDir of config.altSkillsDirs) { + if (existsSync(join(this.projectPath, altDir))) { + if (!detected.includes(agent as AgentType)) { + detected.push(agent as AgentType); + } + break; + } + } + } + } + + if (detected.length === 0) { + detected.push('claude-code', 'cursor', 'github-copilot'); + } + + return detected; + } + + private generateForAgent(agent: AgentType): GeneratedInstruction | null { + if (!this.analysis) return null; + + const config = AGENT_CONFIG[agent]; + const template = AGENT_INSTRUCTION_TEMPLATES[agent] || this.getDefaultTemplate(agent, config); + + const content = this.generateContent(template); + const outputDir = this.options.outputDir || this.projectPath; + const filepath = join(outputDir, template.filename); + + return { + agent, + filename: template.filename, + filepath, + content, + format: template.format, + }; + } + + private getDefaultTemplate(agent: AgentType, config: AgentDirectoryConfig): AgentInstructionTemplate { + return { + agent, + filename: config.configFile, + format: 'markdown', + sectionOrder: ['overview', 'stack', 'commands', 'conventions', 'structure', 'guidelines'], + }; + } + + private generateContent(template: AgentInstructionTemplate): string { + if (!this.analysis) return ''; + + const sections: string[] = []; + + for (const section of template.sectionOrder) { + const content = this.generateSection(section, template); + if (content) { + sections.push(content); + } + } + + let result = sections.join('\n\n'); + + if (template.header) { + result = template.header + '\n\n' + result; + } + + if (template.footer) { + result = result + '\n\n' + template.footer; + } + + if (this.options.customInstructions) { + result += '\n\n## Custom Instructions\n\n' + this.options.customInstructions; + } + + return result; + } + + private generateSection(section: string, template: AgentInstructionTemplate): string { + if (!this.analysis) return ''; + + switch (section) { + case 'overview': + return this.generateOverviewSection(); + case 'stack': + return this.generateStackSection(); + case 'commands': + return this.generateCommandsSection(); + case 'conventions': + return this.generateConventionsSection(); + case 'structure': + return this.generateStructureSection(); + case 'guidelines': + return this.generateGuidelinesSection(template.agent); + default: + return ''; + } + } + + private generateOverviewSection(): string { + if (!this.analysis) return ''; + + const { project, languages } = this.analysis; + const lines: string[] = []; + + lines.push(`# ${project.name}`); + lines.push(''); + + if (project.description) { + lines.push(project.description); + lines.push(''); + } + + if (project.type) { + lines.push(`**Project Type:** ${this.formatProjectType(project.type)}`); + } + + if (languages.length > 0) { + const langNames = languages.map(l => this.capitalize(l.name)).join(', '); + lines.push(`**Languages:** ${langNames}`); + } + + if (project.version) { + lines.push(`**Version:** ${project.version}`); + } + + return lines.join('\n'); + } + + private generateStackSection(): string { + if (!this.analysis) return ''; + + const { stack, packageManagers } = this.analysis; + const lines: string[] = []; + + lines.push('## Technology Stack'); + lines.push(''); + + if (stack.frameworks.length > 0) { + lines.push('### Frameworks'); + for (const fw of stack.frameworks) { + const version = fw.version ? ` (${fw.version})` : ''; + lines.push(`- ${this.capitalize(fw.name)}${version}`); + } + lines.push(''); + } + + if (stack.libraries.length > 0) { + lines.push('### Libraries'); + for (const lib of stack.libraries) { + const version = lib.version ? ` (${lib.version})` : ''; + lines.push(`- ${this.capitalize(lib.name)}${version}`); + } + lines.push(''); + } + + if (stack.styling.length > 0) { + lines.push('### Styling'); + for (const style of stack.styling) { + lines.push(`- ${this.capitalize(style.name)}`); + } + lines.push(''); + } + + if (stack.testing.length > 0) { + lines.push('### Testing'); + for (const test of stack.testing) { + lines.push(`- ${this.capitalize(test.name)}`); + } + lines.push(''); + } + + if (stack.databases.length > 0) { + lines.push('### Databases'); + for (const db of stack.databases) { + lines.push(`- ${this.capitalize(db.name)}`); + } + lines.push(''); + } + + if (packageManagers.length > 0) { + lines.push('### Package Manager'); + lines.push(`- ${packageManagers.map(pm => this.capitalize(pm)).join(', ')}`); + lines.push(''); + } + + return lines.join('\n'); + } + + private generateCommandsSection(): string { + if (!this.analysis || !this.analysis.buildCommands) return ''; + + const { buildCommands } = this.analysis; + const lines: string[] = []; + + lines.push('## Development Commands'); + lines.push(''); + lines.push('```bash'); + + if (buildCommands.install) { + lines.push(`# Install dependencies`); + lines.push(buildCommands.install); + lines.push(''); + } + + if (buildCommands.dev) { + lines.push(`# Start development server`); + lines.push(buildCommands.dev); + lines.push(''); + } + + if (buildCommands.build) { + lines.push(`# Build for production`); + lines.push(buildCommands.build); + lines.push(''); + } + + if (buildCommands.test) { + lines.push(`# Run tests`); + lines.push(buildCommands.test); + lines.push(''); + } + + if (buildCommands.lint) { + lines.push(`# Run linter`); + lines.push(buildCommands.lint); + lines.push(''); + } + + if (buildCommands.format) { + lines.push(`# Format code`); + lines.push(buildCommands.format); + } + + lines.push('```'); + + return lines.join('\n'); + } + + private generateConventionsSection(): string { + if (!this.analysis) return ''; + + const { conventions, patterns } = this.analysis; + const lines: string[] = []; + + lines.push('## Code Conventions'); + lines.push(''); + + if (conventions) { + if (conventions.indentation) { + lines.push(`- **Indentation:** ${conventions.indentation}`); + } + if (conventions.quotes) { + lines.push(`- **Quotes:** ${conventions.quotes}`); + } + if (conventions.semicolons !== undefined) { + lines.push(`- **Semicolons:** ${conventions.semicolons ? 'required' : 'omitted'}`); + } + if (conventions.trailingCommas) { + lines.push(`- **Trailing Commas:** ${conventions.trailingCommas}`); + } + if (conventions.maxLineLength) { + lines.push(`- **Max Line Length:** ${conventions.maxLineLength}`); + } + } + + if (patterns) { + lines.push(''); + lines.push('### Patterns'); + if (patterns.components) { + lines.push(`- **Components:** ${patterns.components}`); + } + if (patterns.stateManagement) { + lines.push(`- **State Management:** ${patterns.stateManagement}`); + } + if (patterns.apiStyle) { + lines.push(`- **API Style:** ${patterns.apiStyle}`); + } + if (patterns.styling) { + lines.push(`- **Styling:** ${patterns.styling}`); + } + if (patterns.testing) { + lines.push(`- **Testing:** ${patterns.testing}`); + } + if (patterns.linting) { + lines.push(`- **Linting:** ${patterns.linting}`); + } + if (patterns.formatting) { + lines.push(`- **Formatting:** ${patterns.formatting}`); + } + } + + return lines.join('\n'); + } + + private generateStructureSection(): string { + if (!this.analysis) return ''; + + const { structure, importantFiles } = this.analysis; + const lines: string[] = []; + + lines.push('## Project Structure'); + lines.push(''); + + if (structure) { + if (structure.type) { + lines.push(`**Structure Type:** ${structure.type}`); + } + if (structure.srcDir) { + lines.push(`**Source Directory:** \`${structure.srcDir}/\``); + } + if (structure.testDir) { + lines.push(`**Test Directory:** \`${structure.testDir}/\``); + } + if (structure.hasWorkspaces && structure.workspaces) { + lines.push(`**Workspaces:** ${structure.workspaces.join(', ')}`); + } + lines.push(''); + } + + if (importantFiles.length > 0) { + lines.push('### Important Files'); + for (const file of importantFiles.slice(0, 15)) { + lines.push(`- \`${file}\``); + } + } + + return lines.join('\n'); + } + + private generateGuidelinesSection(_agent: AgentType): string { + if (!this.analysis) return ''; + + const { stack, patterns } = this.analysis; + const lines: string[] = []; + + lines.push('## Development Guidelines'); + lines.push(''); + + const hasReact = stack.frameworks.some(f => f.name === 'react' || f.name === 'nextjs'); + const hasVue = stack.frameworks.some(f => f.name === 'vue' || f.name === 'nuxt'); + const hasTypeScript = this.analysis.languages.some(l => l.name === 'typescript'); + const hasTailwind = stack.styling.some(s => s.name === 'tailwindcss'); + const hasPrisma = stack.databases.some(d => d.name === 'prisma'); + const hasZod = stack.libraries.some(l => l.name === 'zod'); + + if (hasTypeScript) { + lines.push('### TypeScript'); + lines.push('- Use strict TypeScript with proper type annotations'); + lines.push('- Prefer `interface` for object types, `type` for unions/intersections'); + lines.push('- Avoid `any` - use `unknown` when type is uncertain'); + lines.push(''); + } + + if (hasReact) { + lines.push('### React'); + lines.push('- Use functional components with hooks'); + lines.push('- Prefer composition over inheritance'); + lines.push('- Keep components small and focused'); + if (patterns?.stateManagement) { + lines.push(`- Use ${patterns.stateManagement} for state management`); + } + lines.push(''); + } + + if (hasVue) { + lines.push('### Vue'); + lines.push('- Use Composition API with `