@patricksardinha/agentkit-cli 0.3.0 → 0.5.0

package/src/commands/init.ts

@@ -24,6 +24,45 @@ const FRAMEWORK_LABELS: Record<StackInfo['framework'], string> = {
   unknown: 'Unknown (generic)',
 }
 
+const STACK_CHOICES = [
+  { name: 'React + Vite', value: 'react' },
+  { name: 'Next.js', value: 'nextjs' },
+  { name: 'Tauri v2 (React + Rust)', value: 'tauri' },
+  { name: 'FastAPI (Python)', value: 'fastapi' },
+  { name: 'Express (Node.js)', value: 'express' },
+  { name: 'Node.js (generic)', value: 'node' },
+  { name: 'None of the above — generate a generic CLAUDE.md to fill manually', value: 'none' },
+]
+
+export async function resolveStack(
+  detected: StackInfo,
+): Promise<{ stack: StackInfo; stackNotConfigured: boolean }> {
+  if (detected.framework !== 'unknown') {
+    return { stack: detected, stackNotConfigured: false }
+  }
+
+  logger.warn('Stack not detected automatically.')
+  const { selectedFramework } = await inquirer.prompt<{ selectedFramework: string }>([
+    {
+      type: 'list',
+      name: 'selectedFramework',
+      message: 'Stack not detected automatically. Please select your stack:',
+      choices: STACK_CHOICES as unknown as string[],
+    },
+  ])
+
+  if (selectedFramework === 'none') {
+    return { stack: detected, stackNotConfigured: true }
+  }
+
+  const framework = selectedFramework as StackInfo['framework']
+  const language: StackInfo['language'] = framework === 'fastapi' ? 'python' : 'javascript'
+  return {
+    stack: { ...detected, framework, language, hasTypeScript: false },
+    stackNotConfigured: false,
+  }
+}
+
 async function fileExists(path: string): Promise<boolean> {
   try {
     await readFile(path)
@@ -50,8 +89,10 @@ export function registerInit(program: Command): void {
         logger.warn('Ce dossier n\'est pas un repo git — lancez git init si nécessaire')
       }
 
-      const label = FRAMEWORK_LABELS[stack.framework]
-      logger.info(`Stack détectée : ${label} (${stack.language})`)
+      const { stack: resolvedStack, stackNotConfigured } = await resolveStack(stack)
+
+      const label = FRAMEWORK_LABELS[resolvedStack.framework]
+      logger.info(`Stack : ${label} (${resolvedStack.language})`)
 
       const { confirmed } = await inquirer.prompt<{ confirmed: boolean }>([
         {
@@ -112,8 +153,8 @@ export function registerInit(program: Command): void {
       }
 
       const genSpinner = ora('Génération des fichiers…').start()
-      const claudeMdContent = generateClaudeMd(stack, blueprintContent)
-      const workflowContent = generateWorkflow(stack, blueprintContent)
+      const claudeMdContent = generateClaudeMd(resolvedStack, blueprintContent, stackNotConfigured)
+      const workflowContent = generateWorkflow(resolvedStack, blueprintContent, projectName)
       const agents = extractAgentsFromWorkflow(workflowContent)
       const playbookContent = generatePlaybook({ agents, projectName, hasBlueprint: !!blueprintContent })
       await writeFile(claudeMdPath, claudeMdContent, 'utf-8')

package/src/generators/claudeMdGenerator.ts

@@ -1,5 +1,4 @@
 import type { StackInfo } from '../detectors/stackDetector.js'
-import { parseBlueprint } from '../utils/blueprintParser.js'
 import * as react from '../templates/react.js'
 import * as nextjs from '../templates/nextjs.js'
 import * as tauri from '../templates/tauri.js'
@@ -8,7 +7,19 @@ import * as express from '../templates/express.js'
 import * as node from '../templates/node.js'
 import * as unknown from '../templates/unknown.js'
 
-export function generateClaudeMd(stack: StackInfo, blueprintContent?: string): string {
+const STACK_NOT_CONFIGURED_WARNING = `
+## ⚠️ Stack not configured
+AgentKit could not detect your stack and no stack was selected.
+Before running Claude Code, fill in the following sections:
+- Stack (framework, runtime, DB, tools)
+- Commands (dev, build, test)
+- Structure (folder layout)
+
+Once filled, give Claude Code this instruction:
+"Read PLAYBOOK.md and execute the procedure."
+`
+
+export function generateClaudeMd(stack: StackInfo, blueprintContent?: string, stackNotConfigured?: boolean): string {
   let base: string
   switch (stack.framework) {
     case 'react':   base = react.claudeMd(stack); break
@@ -20,23 +31,18 @@ export function generateClaudeMd(stack: StackInfo, blueprintContent?: string): s
     default:        base = unknown.claudeMd(stack)
   }
 
-  if (!blueprintContent) return base
-
-  const features = parseBlueprint(blueprintContent)
-  if (features.length === 0) return base
+  if (stackNotConfigured) {
+    const firstNewline = base.indexOf('\n')
+    base = base.slice(0, firstNewline + 1) + STACK_NOT_CONFIGURED_WARNING + base.slice(firstNewline + 1)
+  }
 
-  const featureLines = features
-    .map((f, i) => {
-      const sub = f.items.length > 0 ? '\n' + f.items.map((it) => `   - ${it}`).join('\n') : ''
-      return `${i + 1}. **${f.name}**${sub}`
-    })
-    .join('\n')
+  if (!blueprintContent) return base
 
-  const featureSection = `\n## Features (Blueprint)\n\n${featureLines}\n`
+  const blueprintNote = '\n> A PROJECT_BLUEPRINT.md is present — Claude Code will read it during Phase 0.\n'
 
   const conventionsIdx = base.indexOf('\n## Conventions')
   if (conventionsIdx !== -1) {
-    return base.slice(0, conventionsIdx) + featureSection + base.slice(conventionsIdx)
+    return base.slice(0, conventionsIdx) + blueprintNote + base.slice(conventionsIdx)
   }
-  return base + featureSection
+  return base + blueprintNote
 }

package/src/generators/workflowGenerator.ts

@@ -1,6 +1,4 @@
 import type { StackInfo } from '../detectors/stackDetector.js'
-import { parseBlueprint } from '../utils/blueprintParser.js'
-import { toSlug } from '../utils/agentParser.js'
 import * as react from '../templates/react.js'
 import * as nextjs from '../templates/nextjs.js'
 import * as tauri from '../templates/tauri.js'
@@ -9,8 +7,8 @@ import * as express from '../templates/express.js'
 import * as node from '../templates/node.js'
 import * as unknown from '../templates/unknown.js'
 
-export function generateWorkflow(stack: StackInfo, blueprintContent?: string): string {
-  if (blueprintContent) return blueprintWorkflow(stack, blueprintContent)
+export function generateWorkflow(stack: StackInfo, blueprintContent?: string, projectName?: string): string {
+  if (blueprintContent) return blueprintPlaceholder(projectName ?? stack.framework)
 
   switch (stack.framework) {
     case 'react':   return react.workflow(stack)
@@ -23,40 +21,15 @@ export function generateWorkflow(stack: StackInfo, blueprintContent?: string): s
   }
 }
 
-function blueprintWorkflow(stack: StackInfo, blueprintContent: string): string {
-  const features = parseBlueprint(blueprintContent)
+function blueprintPlaceholder(projectName: string): string {
+  return `# AGENT_WORKFLOW.md — ${projectName}
 
-  const agentBlocks = features.map((feature, i) => {
-    const n = i + 1
-    const slug = toSlug(feature.name)
-    const outputLines =
-      feature.items.length > 0
-        ? feature.items.map((item) => `  - ${item}`).join('\n')
-        : `  - src/${slug}/`
-    return `### Agent ${n} · ${feature.name}
-Périmètre : Implémenter la fonctionnalité ${feature.name.toLowerCase()}
-Produit   :
-${outputLines}
-Critère   : npm test (tests ${feature.name.toLowerCase()} passent)`
-  })
+> This file will be filled in by Claude Code during Phase 0.
+> Claude Code will read PROJECT_BLUEPRINT.md, propose a decomposition,
+> and replace this content after human validation.
 
-  const ciN = features.length + 1
-  agentBlocks.push(
-    `### Agent ${ciN} · Tests & CI
-Périmètre : Couverture de tests complète et configuration du pipeline CI
-Produit   :
-  - tests/
-  - .github/workflows/
-Critère   : npm test passe, pipeline CI vert`,
-  )
+---
 
-  return `# Agent Workflow — ${stack.framework} (Blueprint)
-
-## Stack détectée
-Framework: ${stack.framework} | Language: ${stack.language}
-
-## Agents
-
-${agentBlocks.join('\n\n')}
+*Waiting for Phase 0 decomposition...*
 `
 }

package/tests/commands/init.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import type { StackInfo } from '../../src/detectors/stackDetector.js'
+
+vi.mock('inquirer', () => ({
+  default: {
+    prompt: vi.fn(),
+  },
+}))
+
+vi.mock('../../src/utils/logger.js', () => ({
+  logger: {
+    info: vi.fn(),
+    success: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}))
+
+import inquirer from 'inquirer'
+import { resolveStack } from '../../src/commands/init.js'
+import { generateClaudeMd } from '../../src/generators/claudeMdGenerator.js'
+
+function makeStack(
+  framework: StackInfo['framework'],
+  opts: Partial<Omit<StackInfo, 'framework'>> = {},
+): StackInfo {
+  return {
+    framework,
+    language: framework === 'fastapi' ? 'python' : opts.hasTypeScript ? 'typescript' : 'javascript',
+    hasTypeScript: opts.hasTypeScript ?? false,
+    extras: opts.extras ?? [],
+    ...opts,
+  }
+}
+
+describe('resolveStack', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('returns detected stack unchanged when framework is not unknown — no prompt shown', async () => {
+    const detected = makeStack('react', { hasTypeScript: true })
+    const result = await resolveStack(detected)
+
+    expect(result.stack).toEqual(detected)
+    expect(result.stackNotConfigured).toBe(false)
+    expect(vi.mocked(inquirer.prompt)).not.toHaveBeenCalled()
+  })
+
+  it('does not prompt for any known framework', async () => {
+    const frameworks: StackInfo['framework'][] = ['nextjs', 'tauri', 'fastapi', 'express', 'node']
+    for (const framework of frameworks) {
+      vi.clearAllMocks()
+      const result = await resolveStack(makeStack(framework))
+      expect(result.stackNotConfigured).toBe(false)
+      expect(vi.mocked(inquirer.prompt)).not.toHaveBeenCalled()
+    }
+  })
+
+  it('prompts for stack selection when framework is unknown', async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValueOnce({ selectedFramework: 'tauri' })
+
+    const result = await resolveStack(makeStack('unknown'))
+
+    expect(vi.mocked(inquirer.prompt)).toHaveBeenCalledOnce()
+    expect(result.stack.framework).toBe('tauri')
+    expect(result.stack.language).toBe('javascript')
+    expect(result.stackNotConfigured).toBe(false)
+  })
+
+  it('unknown + user selects Tauri → stack.framework is tauri', async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValueOnce({ selectedFramework: 'tauri' })
+
+    const result = await resolveStack(makeStack('unknown'))
+
+    expect(result.stack.framework).toBe('tauri')
+    expect(result.stackNotConfigured).toBe(false)
+  })
+
+  it('unknown + user selects FastAPI → language is python', async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValueOnce({ selectedFramework: 'fastapi' })
+
+    const result = await resolveStack(makeStack('unknown'))
+
+    expect(result.stack.framework).toBe('fastapi')
+    expect(result.stack.language).toBe('python')
+    expect(result.stackNotConfigured).toBe(false)
+  })
+
+  it('unknown + user selects "None of the above" → stackNotConfigured is true, framework stays unknown', async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValueOnce({ selectedFramework: 'none' })
+
+    const result = await resolveStack(makeStack('unknown'))
+
+    expect(result.stack.framework).toBe('unknown')
+    expect(result.stackNotConfigured).toBe(true)
+  })
+})
+
+describe('generateClaudeMd — stackNotConfigured warning', () => {
+  it('includes warning block when stackNotConfigured is true', () => {
+    const result = generateClaudeMd(makeStack('unknown'), undefined, true)
+    expect(result).toContain('⚠️ Stack not configured')
+    expect(result).toContain('AgentKit could not detect your stack')
+    expect(result).toContain('Stack (framework, runtime, DB, tools)')
+    expect(result).toContain('Read PLAYBOOK.md and execute the procedure.')
+  })
+
+  it('does not include warning block when stackNotConfigured is false', () => {
+    const result = generateClaudeMd(makeStack('unknown'), undefined, false)
+    expect(result).not.toContain('⚠️ Stack not configured')
+  })
+
+  it('does not include warning block when stackNotConfigured is omitted', () => {
+    const result = generateClaudeMd(makeStack('unknown'))
+    expect(result).not.toContain('⚠️ Stack not configured')
+  })
+
+  it('unknown + None selected → uses unknown template content', () => {
+    const result = generateClaudeMd(makeStack('unknown'), undefined, true)
+    expect(result).toContain('## Stack')
+    expect(result).toContain('## Commands')
+    expect(result).toContain('## Conventions')
+  })
+
+  it('unknown + Tauri selected → resolveStack returns tauri, generateClaudeMd uses tauri template', async () => {
+    vi.mocked(inquirer.prompt).mockResolvedValueOnce({ selectedFramework: 'tauri' })
+
+    const { stack, stackNotConfigured } = await resolveStack(makeStack('unknown'))
+    const result = generateClaudeMd(stack, undefined, stackNotConfigured)
+
+    expect(stack.framework).toBe('tauri')
+    expect(stackNotConfigured).toBe(false)
+    expect(result).toContain('Tauri')
+    expect(result).toContain('Rust')
+    expect(result).not.toContain('⚠️ Stack not configured')
+  })
+
+  it('warning block still present alongside blueprint note when both are set', () => {
+    const blueprint = '# My App\n\n## Goal\nSomething\n'
+    const result = generateClaudeMd(makeStack('unknown'), blueprint, true)
+    expect(result).toContain('⚠️ Stack not configured')
+    expect(result).toContain('PROJECT_BLUEPRINT.md is present')
+  })
+})

package/tests/generators/blueprintSupport.test.ts

@@ -63,27 +63,30 @@ describe('generateClaudeMd with blueprint', () => {
     expect(generateClaudeMd(REACT_STACK)).toBe(generateClaudeMd(REACT_STACK, undefined))
   })
 
-  it('includes a Features section when blueprint is provided', () => {
+  it('adds the blueprint note when blueprint is provided', () => {
     const result = generateClaudeMd(REACT_STACK, BLUEPRINT)
-    expect(result).toContain('## Features (Blueprint)')
-    expect(result).toContain('Authentication')
-    expect(result).toContain('Dashboard')
-    expect(result).toContain('API')
+    expect(result).toContain('PROJECT_BLUEPRINT.md is present')
+    expect(result).toContain('Phase 0')
   })
 
-  it('includes blueprint sub-items', () => {
+  it('does NOT include a Features (Blueprint) section', () => {
     const result = generateClaudeMd(REACT_STACK, BLUEPRINT)
-    expect(result).toContain('JWT tokens')
-    expect(result).toContain('User statistics')
+    expect(result).not.toContain('## Features (Blueprint)')
   })
 
-  it('places Features section before Conventions', () => {
+  it('does NOT include blueprint sub-items as feature bullets', () => {
     const result = generateClaudeMd(REACT_STACK, BLUEPRINT)
-    const featIdx = result.indexOf('## Features (Blueprint)')
+    expect(result).not.toContain('JWT tokens')
+    expect(result).not.toContain('User statistics')
+  })
+
+  it('places blueprint note before Conventions', () => {
+    const result = generateClaudeMd(REACT_STACK, BLUEPRINT)
+    const noteIdx = result.indexOf('PROJECT_BLUEPRINT.md is present')
     const convIdx = result.indexOf('## Conventions')
-    expect(featIdx).toBeGreaterThan(-1)
+    expect(noteIdx).toBeGreaterThan(-1)
     expect(convIdx).toBeGreaterThan(-1)
-    expect(featIdx).toBeLessThan(convIdx)
+    expect(noteIdx).toBeLessThan(convIdx)
   })
 
   it('still contains stack-specific content', () => {
@@ -98,33 +101,35 @@ describe('generateWorkflow with blueprint', () => {
     expect(generateWorkflow(REACT_STACK)).toBe(generateWorkflow(REACT_STACK, undefined))
   })
 
-  it('generates one agent per blueprint feature plus a CI agent', () => {
+  it('returns a Phase 0 placeholder instead of agent blocks', () => {
     const result = generateWorkflow(REACT_STACK, BLUEPRINT)
-    expect(result).toContain('Agent 1 · Authentication')
-    expect(result).toContain('Agent 2 · Dashboard')
-    expect(result).toContain('Agent 3 · API')
-    expect(result).toContain('Agent 4 · Tests & CI')
+    expect(result).toContain('AGENT_WORKFLOW.md')
+    expect(result).toContain('Phase 0')
+    expect(result).toContain('PROJECT_BLUEPRINT.md')
+    expect(result).toContain('Waiting for Phase 0 decomposition')
   })
 
-  it('each agent block is parseable by extractAgentsFromWorkflow', () => {
+  it('does NOT generate agent blocks from blueprint sections', () => {
     const result = generateWorkflow(REACT_STACK, BLUEPRINT)
-    const agents = extractAgentsFromWorkflow(result)
-    expect(agents).toHaveLength(4)
-    expect(agents[0].name).toBe('Authentication')
-    expect(agents[0].slug).toBe('authentication')
-    expect(agents[3].name).toBe('Tests & CI')
-    expect(agents[3].slug).toBe('tests-ci')
+    expect(result).not.toContain('Agent 1')
+    expect(result).not.toContain('Authentication')
+    expect(result).not.toContain('Dashboard')
+    expect(result).not.toContain('Tests & CI')
   })
 
-  it('includes blueprint feature items as outputs', () => {
+  it('does NOT include blueprint feature items as outputs', () => {
     const result = generateWorkflow(REACT_STACK, BLUEPRINT)
-    expect(result).toContain('JWT tokens')
-    expect(result).toContain('User statistics')
+    expect(result).not.toContain('JWT tokens')
+    expect(result).not.toContain('User statistics')
+  })
+
+  it('uses projectName in heading when provided', () => {
+    const result = generateWorkflow(REACT_STACK, BLUEPRINT, 'my-app')
+    expect(result).toContain('AGENT_WORKFLOW.md — my-app')
   })
 
-  it('includes stack information in the header', () => {
+  it('falls back to framework name when projectName is omitted', () => {
     const result = generateWorkflow(REACT_STACK, BLUEPRINT)
-    expect(result).toContain('react')
-    expect(result).toContain('typescript')
+    expect(result).toContain('AGENT_WORKFLOW.md — react')
   })
 })

package/tests/generators/claudeMdGenerator.test.ts

@@ -83,4 +83,52 @@ describe('generateClaudeMd', () => {
     expect(typeof result).toBe('string')
     expect(result.length).toBeGreaterThan(0)
   })
+
+  describe('blueprint note', () => {
+    const blueprint = `# My Project\n\n## Goal\nBuild something\n\n## Features\n- Auth\n- Dashboard\n`
+
+    it('adds the blueprint note when blueprintContent is provided', () => {
+      const result = generateClaudeMd(makeStack('react'), blueprint)
+      expect(result).toContain('PROJECT_BLUEPRINT.md is present')
+      expect(result).toContain('Phase 0')
+    })
+
+    it('does NOT list blueprint sections as features', () => {
+      const result = generateClaudeMd(makeStack('react'), blueprint)
+      expect(result).not.toContain('Features (Blueprint)')
+      expect(result).not.toContain('**Goal**')
+      expect(result).not.toContain('**Features**')
+    })
+
+    it('still contains the stack-based template content', () => {
+      const result = generateClaudeMd(makeStack('react'), blueprint)
+      expect(result).toContain('React')
+      expect(result).toContain('## Stack')
+      expect(result).toContain('## Commands')
+    })
+
+    it('adds blueprint note for unknown stack with blueprint', () => {
+      const result = generateClaudeMd(makeStack('unknown'), blueprint)
+      expect(result).toContain('PROJECT_BLUEPRINT.md is present')
+      expect(result).toContain('Phase 0')
+    })
+
+    it('returns base template unchanged when blueprintContent is absent', () => {
+      const withBlueprint = generateClaudeMd(makeStack('react'), blueprint)
+      const withoutBlueprint = generateClaudeMd(makeStack('react'))
+      expect(withBlueprint).not.toBe(withoutBlueprint)
+      expect(withoutBlueprint).not.toContain('PROJECT_BLUEPRINT.md is present')
+    })
+
+    it('adds blueprint note for every framework', () => {
+      const frameworks: StackInfo['framework'][] = [
+        'react', 'nextjs', 'tauri', 'fastapi', 'express', 'node', 'unknown',
+      ]
+      for (const framework of frameworks) {
+        const result = generateClaudeMd(makeStack(framework), blueprint)
+        expect(result).toContain('PROJECT_BLUEPRINT.md is present')
+        expect(result).not.toContain('Features (Blueprint)')
+      }
+    })
+  })
 })

package/tests/generators/workflowGenerator.test.ts

@@ -81,4 +81,44 @@ describe('generateWorkflow', () => {
     expect(typeof result).toBe('string')
     expect(result.length).toBeGreaterThan(0)
   })
+
+  describe('blueprint placeholder', () => {
+    const blueprint = `# My Project\n\n## Goal\nBuild something\n\n## Features\n- Auth\n- Dashboard\n`
+
+    it('returns a placeholder when blueprintContent is provided', () => {
+      const result = generateWorkflow(makeStack('react'), blueprint)
+      expect(result).toContain('AGENT_WORKFLOW.md')
+      expect(result).toContain('Phase 0')
+      expect(result).toContain('PROJECT_BLUEPRINT.md')
+      expect(result).toContain('Waiting for Phase 0 decomposition')
+    })
+
+    it('uses projectName in heading when provided', () => {
+      const result = generateWorkflow(makeStack('react'), blueprint, 'my-app')
+      expect(result).toContain('AGENT_WORKFLOW.md — my-app')
+    })
+
+    it('falls back to framework name when projectName is omitted', () => {
+      const result = generateWorkflow(makeStack('react'), blueprint)
+      expect(result).toContain('AGENT_WORKFLOW.md — react')
+    })
+
+    it('does NOT parse blueprint sections as agents', () => {
+      const result = generateWorkflow(makeStack('react'), blueprint, 'my-app')
+      expect(result).not.toContain('Agent · Goal')
+      expect(result).not.toContain('Agent · Features')
+      expect(result).not.toContain('Agent 1')
+    })
+
+    it('returns the placeholder for every framework when blueprint is provided', () => {
+      const frameworks: StackInfo['framework'][] = [
+        'react', 'nextjs', 'tauri', 'fastapi', 'express', 'node', 'unknown',
+      ]
+      for (const framework of frameworks) {
+        const result = generateWorkflow(makeStack(framework), blueprint, 'proj')
+        expect(result).toContain('Phase 0')
+        expect(result).not.toContain('Agent 1')
+      }
+    })
+  })
 })