- 3 Workflow Modes: small (bug fixes), medium (features), large (architecture)
- Auto-detection: Smart mode selection based on feature name patterns
- itda-release: New CLI for release automation with CHANGELOG generation

`bash


Generate CHANGELOG from commits

- Package Registry: steering/packages.yml for dependency management
- Dependency Graphs: Mermaid diagram generation for visualization
- Coverage Tracking: Per-package test coverage reporting

#### Constitution Level Management (Phase 3)

- 3 Enforcement Levels: critical (blocking), advisory (warnings), flexible (suggestions)
- Level-aware Validation: Different enforcement based on article importance
- Project Overrides: Custom levels per project type

| Level | Articles | Behavior |
|-------|----------|----------|
| Critical | CONST-001, 002, 003, 005, 009 | Blocks workflow |
| Advisory | CONST-004, 006, 007 | Warnings only |
| Flexible | CONST-008 | Suggestions |

#### Project Configuration (Phase 4)

- itda-config: New CLI for configuration management
- Schema Validation: v2.0 schema with AJV validation
- Auto-migration: Upgrade v1.0 configs to v2.0

`bash
itda-config validate # Validate project.yml
itda-config migrate # Migrate to v2.0
itda-config show # Show effective config
`

#### Orchestrator Integration

5 new built-in skills for programmatic access:

| Skill | Category | Usage |
|-------|----------|-------|
| release-manager | release | CHANGELOG generation |
| workflow-mode-manager | workflow | Mode detection & management |
| package-manager | configuration | Package & dependency analysis |
| constitution-level-manager | validation | Level-aware validation |
| project-config-manager | configuration | Config validation & migration |

`javascript
const { workflowModeSkill } = require('itda-sdd/src/orchestration');

const result = await workflowModeSkill.execute({
action: 'detect',
featureName: 'fix: minor bug'
});
console.log(result.detectedMode); // 'small'
`

---

📊 What's New in v5.8.0

$3

Major update to CodeGraph MCP integration with expanded language support and new features.

#### 16 Language Support (NEW: Kotlin, Swift, Scala, Lua)

- Python, TypeScript, JavaScript - Full AST analysis
- Rust, Go, Java, PHP, C# - Enterprise language support
- C, C++, HCL (Terraform) - System and infrastructure code
- Ruby - Dynamic language support
- Kotlin (NEW) - .kt, .kts files with classes, interfaces, functions
- Swift (NEW) - .swift files with classes, structs, protocols
- Scala (NEW) - .scala, .sc files with traits, objects
- Lua (NEW) - .lua files with functions, table assignments

#### File Watching & Auto Re-indexing

- codegraph-mcp watch - Real-time file monitoring
- Debounce configuration - Configurable delay (default: 1.0s)
- Community detection - Optional --community flag after re-index

#### Enhanced MCP Tools (14 Tools)

| Category | Tools |
|----------|-------|
| Graph Query | query_codebase, find_dependencies, find_callers, find_callees, find_implementations, analyze_module_structure |
| Code Retrieval | get_code_snippet, read_file_content, get_file_structure |
| GraphRAG | global_search, local_search |
| Management | suggest_refactoring, reindex_repository, execute_shell_command |

#### Security & Performance (v0.7.3)

- Security fixes: Path traversal and command injection protection
- Connection pooling: Improved database performance
- Caching: Faster repeated queries

`javascript
// Use CodeGraph MCP integration
const { CodeGraphIntegration } = require('itda-sdd');

const cg = new CodeGraphIntegration('/path/to/repo');
await cg.indexRepository();

// File watching (v0.7.0+)
await cg.startWatch({ debounce: 2.0, community: true });

// Query codebase
const results = await cg.queryCodebase('authentication');
const callers = await cg.findCallers('UserService::login');
`

---

📊 What's New in v5.6.0

$3

Major improvements based on analysis of GCC codebase (10+ million lines, 100,000+ files).

#### Large Project Analyzer

- Scale-aware analysis: Automatically detects project size and selects appropriate strategy
- Memory-efficient processing: Chunk-based processing with garbage collection for 100K+ files
- Multi-language support: JavaScript, TypeScript, C, C++, Python, Rust, Go, Java
- Giant function detection: Flags functions with 100+ (warning), 500+ (critical), 1000+ (extreme) lines

#### CodeGraph MCP Integration

- Deep code graph analysis: Integration with CodeGraph MCP for relationship analysis
- Call graph generation: Track callers and callees with configurable depth
- Impact analysis: Identify affected files when code changes
- Hotspot identification: Detect highly-connected entities (refactoring candidates)

#### Enhanced Complexity Analyzer

- Cyclomatic complexity: Standard decision-point counting
- Cognitive complexity: SonarSource-style readability measurement
- Severity levels: Ideal → Warning → Critical → Extreme thresholds

#### Rust Migration Generator

- Unsafe pattern detection: Identify C/C++ memory-unsafe patterns
- Migration priority scoring: Automatic prioritization for Rust migration
- Security component analysis: Flag security-critical code sections

`javascript
// Analyze enterprise-scale projects (100,000+ files)
const { LargeProjectAnalyzer, ComplexityAnalyzer } = require('itda-sdd');

const analyzer = new LargeProjectAnalyzer('/path/to/gcc');
const result = await analyzer.analyze();
console.log(result.stats); // { totalFiles: 109073, ... }

// Calculate code complexity
const complexity = new ComplexityAnalyzer();
const score = complexity.calculateCyclomaticComplexity(code, 'javascript');
`

$3

- 🔗 --reference / -r Option - Reference multiple GitHub repositories for pattern analysis
- 📊 Repository Analysis - Fetch metadata, structure, and key files via GitHub API
- 🏗️ Pattern Detection - Clean Architecture, Hexagonal, DDD, Monorepo patterns
- 💡 Improvement Suggestions - Architecture and technology recommendations
- 📁 Analysis Output - Saved to steering/references/github-references-YYYY-MM-DD.md

`bash


Reference multiple repositories for improvement suggestions

`bash


Use advanced features via orchestrator

- 🌐 WebSocket Real-time GUI - Live replanning updates with itda-browser dashboard
- 📋 GUI Quick Actions - Modal dialog for New Requirement, Validate Project, Export Report
- 🔄 GitHub Actions Integration - itda-action for CI/CD with ITDA validation
- 🔧 OpenAPI Converter - Convert OpenAPI 3.x/Swagger 2.x specs to ITDA format
- 🌍 Multi-language Templates - 7 language support (EN, JA, ZH, KO, ES, DE, FR)
- 🤖 Ollama Integration - Local LLM support with 9 model presets

$3

- 🧠 Dynamic Replanning Engine - AI agents can now dynamically adjust plans when tasks fail
- 🔌 LLM Provider Abstraction - Multi-provider support (Copilot, Anthropic, OpenAI)
- 📡 Real-time Plan Monitoring - Detect failures, timeouts, and quality degradation
- 🔄 Alternative Path Generation - LLM-powered alternative strategies with confidence scoring
- 📝 Replan History & Audit - Full audit trail with JSONL persistence and export

$3

- 🔄 Workflow Engine - New itda-workflow CLI for stage management and metrics
- 📊 Metrics Collection - Track time per stage, iteration counts, feedback loops
- 🔬 Spike/PoC Stage - Stage 0 for research and prototyping before requirements
- 👀 Code Review Stage - Stage 5.5 between implementation and testing
- 🔄 Retrospective Stage - Stage 9 for continuous improvement
- ✅ Stage Validation Guide - Checklists for stage transition validation

$3

- 🔧 CLI Integration - Added CLI command references to all 8 Claude Code skills
- 📚 Platform Documentation - CLI Commands section added to all 6 non-Claude platforms

$3

- 🔌 CodeGraphMCPServer Integration - 14 MCP tools for enhanced code analysis
- 🧠 GraphRAG-Powered Search - Semantic code understanding with Louvain community detection
- 🔍 11 Agents Enhanced - Key agents now leverage MCP tools for deeper code analysis

Features

- 🤖 Multi-Agent Support - Works with 7 AI coding agents (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Codex CLI, Qwen Code, Windsurf)
- 🧠 Dynamic Replanning - AI agents dynamically adjust plans on failure with LLM-powered alternatives (v3.6.0+)
- 🔌 MCP Server Integration - CodeGraphMCPServer for advanced code analysis (v2.0.0)
- 📄 Flexible Command Formats - Supports Markdown, TOML, and AGENTS.md formats
- 🎯 27 Specialized Skills (All Platforms) - 25 platform agents + 5 orchestrator built-in skills (v5.9.0)
- Claude Code: Skills API (25 skills + 5 built-in)
- GitHub Copilot & Cursor: AGENTS.md (official support)
- Other 4 agents: AGENTS.md (compatible format)
- 📋 Constitutional Governance - 9 immutable articles + Phase -1 Gates for quality enforcement
- 📝 EARS Requirements Generator - Create unambiguous requirements with 5 EARS patterns (v0.8.0)
- 🏗️ Design Document Generator - Create C4 models and ADRs with traceability (v0.8.2)
- 🔄 Change Management System - Delta specifications for brownfield projects (v0.8.6)
- 🔍 Gap Detection System - Identify orphaned requirements and untested code (v0.8.7)
- 🧭 Auto-Updating Project Memory - Steering system maintains architecture, tech stack, and product context
- 🚀 Automatic Onboarding - itda-onboard analyzes existing projects and generates steering docs (2-5 minutes)
- 🔄 Auto-Sync - itda-sync detects codebase changes and keeps steering docs current
- 🔍 Intelligent Code Analysis - itda-analyze provides quality metrics, complexity analysis, and technical debt detection
- 🤝 Team Collaboration - itda-share enables memory sharing, import/export, and multi-platform sync (v0.6.0)
- ✅ Constitutional Validation - itda-validate enforces 9 immutable governance articles with Phase -1 Gates (v0.7.0)
- ✅ Complete Traceability - Requirements → Design → Code → Tests mapping
- 🌐 Bilingual Documentation - All agent-generated documents created in both English and Korean

Supported AI Coding Agents

ITDA supports 7 AI coding agents, each with tailored configurations:

| Agent | Skills API | 27 Skills | Command Format | Command File Format | Installation Directory |
| ------------------ | -------------- | -------------- | ---------------- | ------------------------- | --------------------------------------------- |
| Claude Code | ✅ (27 skills) | ✅ | /sdd-* | Markdown (.md) | .claude/skills/, .claude/commands/ |
| GitHub Copilot | ❌ | ✅ (AGENTS.md) | /sdd-* | Prompt File (.prompt.md) | .github/prompts/, .github/AGENTS.md |
| Cursor IDE | ❌ | ✅ (AGENTS.md) | /sdd-* | Markdown + AGENTS.md | .cursor/commands/, .cursor/AGENTS.md |
| Gemini CLI | ❌ | ✅ (GEMINI.md) | /sdd-* | TOML + GEMINI.md | .gemini/commands/, GEMINI.md |
| Codex CLI | ❌ | ✅ (AGENTS.md) | /prompts:sdd-* | Markdown + AGENTS.md | .codex/prompts/, .codex/AGENTS.md |
| Qwen Code | ❌ | ✅ (AGENTS.md) | /sdd-* | Markdown + AGENTS.md | .qwen/commands/, .qwen/AGENTS.md |
| Windsurf IDE | ❌ | ✅ (AGENTS.md) | /sdd-* | Markdown + AGENTS.md | .windsurf/workflows/, .windsurf/AGENTS.md |

Notes:

- Skills API is exclusive to Claude Code
- All 7 platforms now support 27 skills via Skills API (Claude Code) or AGENTS.md (others)
- v5.9.0 added 5 built-in orchestrator skills (release, workflow, package, constitution-level, project-config)
- GitHub Copilot uses .prompt.md extension per VS Code official documentation
- AGENTS.md: OpenAI specification, officially supported by GitHub Copilot & Cursor
- Gemini CLI uses TOML format + GEMINI.md integration

---

Constitutional Governance

ITDA enforces 9 Constitutional Articles for quality assurance:

`bash


Validate constitutional compliance

`bash


Initialize ITDA for your preferred agent

Claude Code (default) - 27 Skills (25 + 5 built-in)

Comprehensive guides are available in docs/guides/:

- Brownfield Tutorial - Step-by-step guide for managing changes in existing projects
- Delta Specification Guide - Format reference for change tracking
- Change Management Workflow - End-to-end workflow documentation
- Traceability Matrix Guide - Traceability system usage
- Video Tutorial Plan - Video content script

$3

During initialization, ITDA asks you to select a Project Type. This determines the workflow and features available:

#### Greenfield (0→1)

- What it is: Starting a new project from scratch
- Use cases:
- New application development
- Proof-of-concept projects
- Greenfield microservices
- Features enabled:
- Full 8-stage SDD workflow (Research → Monitoring)
- /sdd-steering - Generate initial project memory
- /sdd-requirements - Create new requirements from scratch
- /sdd-design - Design architecture (C4 model + ADR)
- /sdd-tasks - Break requirements into tasks
- /sdd-implement - Implement features (test-first)
- /sdd-validate - Constitutional compliance checks
- Benefits:
- Clean start with best practices enforced
- Constitutional governance from day one
- Complete traceability from requirements to code

#### Brownfield (1→n)

- What it is: Working with existing codebases
- Use cases:
- Adding features to existing applications
- Refactoring legacy code
- Migrating/modernizing systems
- Features enabled:
- Delta Specifications (ADDED/MODIFIED/REMOVED)
- /sdd-change-init - Create change proposal
- /sdd-change-apply - Apply changes with impact analysis
- /sdd-change-archive - Archive completed changes
- change-impact-analyzer skill (Claude Code) - Automatic impact detection
- Reverse engineering: /sdd-steering analyzes existing code
- Benefits:
- Safe incremental changes with impact analysis
- Preserves existing architecture while improving incrementally
- Full audit trail of what changed and why

#### Both

- What it is: Hybrid approach for complex scenarios
- Use cases:
- Monolith → Microservices migration (brownfield + greenfield services)
- Platform modernization (keep some, rebuild others)
- Multi-component systems with mixed maturity
- Features enabled:
- All Greenfield + Brownfield features
- Flexibility to choose workflow per component
- Mixed delta specs and greenfield specs in same project
- Benefits:
- Maximum flexibility for complex transformation projects
- Unified steering/governance across all components
- Single tool for entire modernization journey

Example Selection:

`text
? Project type:
❯ Greenfield (0→1) ← New projects
Brownfield (1→n) ← Existing codebases
Both ← Complex/hybrid scenarios
`

$3

#### Claude Code (Skills API)

`text
your-project/
├── .claude/
│ ├── skills/ # 25 Skills API + 5 built-in (Claude Code exclusive)
│ │ ├── orchestrator/
│ │ ├── steering/
│ │ ├── requirements-analyst/
│ │ └── ... (22 more)
│ ├── commands/ # Slash commands (/sdd-*)
│ └── CLAUDE.md # Claude Code guide
├── steering/ # Project memory (all agents)
│ ├── project.yml # Project configuration (v0.2.1+)
│ ├── structure.md # Architecture patterns
│ ├── tech.md # Technology stack
│ ├── product.md # Product context
│ ├── memories/ # Persistent knowledge (v0.2.0+)
│ │ ├── architecture_decisions.md
│ │ ├── development_workflow.md
│ │ ├── domain_knowledge.md
│ │ ├── lessons_learned.md
│ │ ├── suggested_commands.md
│ │ └── technical_debt.md
│ └── rules/
│ ├── constitution.md # 9 Constitutional Articles
│ ├── workflow.md # 8-Stage SDD workflow
│ └── ears-format.md # EARS syntax guide
├── templates/ # Document templates (all agents)
└── storage/ # Specs, changes, features (all agents)
`

#### Other Agents (GitHub Copilot, Cursor, Gemini, etc.)

`text
your-project/
├── .github/prompts/ # For GitHub Copilot (/sdd-*, .prompt.md)
│ ├── sdd-steering.prompt.md # Prompt files use .prompt.md extension
│ ├── sdd-requirements.prompt.md
│ ├── ... (9 prompt files)
│ └── AGENTS.md # 27 skills definition (official support)
│ OR
├── .cursor/commands/ # For Cursor (/sdd-*, Markdown)
│ ├── AGENTS.md # 27 skills definition (official support)
│ OR
├── .gemini/commands/ # For Gemini CLI (/sdd-*, TOML)
│ │ ├── sdd-steering.toml
│ │ ├── sdd-requirements.toml
│ │ └── ... (6 TOML files)
│ OR
├── .codex/prompts/ # For Codex CLI (/prompts:sdd-*, Markdown)
│ ├── AGENTS.md # 27 skills definition
│ OR
├── .qwen/commands/ # For Qwen Code (/sdd-*, Markdown)
│ ├── AGENTS.md # 27 skills definition
│ OR
├── .windsurf/workflows/ # For Windsurf (/sdd-*, Markdown)
│ ├── AGENTS.md # 27 skills definition
│
├── GEMINI.md (root, for Gemini) # 27 skills integrated into existing file
├── steering/ # Project memory (same for all)
│ ├── project.yml # Project configuration (v0.2.1+)
│ ├── memories/ # Persistent knowledge (v0.2.0+)
│ │ ├── architecture_decisions.md
│ │ ├── development_workflow.md
│ │ ├── domain_knowledge.md
│ │ ├── lessons_learned.md
│ │ ├── suggested_commands.md
│ │ └── technical_debt.md
│ └── ... (structure.md, tech.md, product.md, rules/)
├── templates/ # Document templates (same for all)
└── storage/ # Specs, changes, features (same for all)
`

Key Differences:

- Claude Code: 27 Skills (25 + 5 built-in) + commands (Markdown)
- GitHub Copilot: AGENTS.md (official support) + prompt files (.prompt.md)
- Cursor: AGENTS.md (official support) + commands (Markdown)
- Gemini CLI: GEMINI.md integration (27 skills) + TOML commands (unique)
- Others: AGENTS.md (compatible) + Markdown commands
- All platforms: Same 27 skills, different implementation formats

Usage

$3

ITDA provides several CLI commands for project management:

`bash


Show version

`text
🚀 ITDA Onboarding Wizard

Analyzing your project...

✅ Project structure analyzed
✅ Technology stack detected
- Node.js, TypeScript, React, Jest
✅ Steering documents generated
- steering/structure.md (en + ko)
- steering/tech.md (en + ko)
- steering/product.md (en + ko)
✅ Memories initialized (6 files)
✅ Project configuration created
- steering/project.yml

⏱️ Onboarding completed in 2.5 minutes

💡 Next steps:
- Review generated steering docs
- Run: itda-sync to keep docs current
- Create requirements: /sdd-requirements [feature]
`

Features:

- Automatic codebase analysis (package.json, directory structure)
- Technology stack detection (languages, frameworks)
- Bilingual steering docs generation (English + Korean)
- Memory system initialization (6 memory files)
- Project configuration (project.yml)
- 96% time reduction (2-4 hours → 2-5 minutes)

#### itda-sync

Detects codebase changes and keeps steering documents synchronized:

`text
🔄 ITDA Steering Sync

Detected changes:
📦 Version: 0.3.0 → 0.4.0
➕ New framework: js-yaml@4.1.0
📁 New directory: bin/

? Apply these changes? (Y/n) Y

✅ Updated steering/project.yml
✅ Updated steering/tech.md (en + ko)
✅ Updated steering/structure.md (en + ko)
✅ Recorded change in memories/architecture_decisions.md

🎉 Steering synchronized successfully!
`

Features:

- Change detection (version, languages, frameworks, directories)
- Interactive mode (default): Show changes, ask confirmation
- Auto-approve mode (--auto-approve): CI/CD integration
- Dry-run mode (--dry-run): Preview only
- Bilingual updates (English + Korean together)
- Memory recording (audit trail)

Usage:

`bash


Interactive (default)

`text
📤 ITDA Memory Export

Export Summary:
File: team-memories.json
Format: json
Size: 1098.28 KB
Memories: 7 files
Agents: 1 platforms
`

Features:

- Export: Share memories as JSON/YAML
- Import: Merge memories from teammates
- Sync: Synchronize across AI platforms
- Conflict Resolution: Interactive, auto-accept, keep-local, or merge with markers
- Status: Show installed platforms and memory counts

Usage:

`bash


Export memories

`text
📊 ITDA Project Status

✅ ITDA is initialized

📁 Claude Code Skills: 27 installed (25 + 5 built-in)
Location: .claude/skills/

🧭 Steering Context:
✅ structure.md (updated: 2025-11-16)
✅ tech.md (updated: 2025-11-16)
✅ product.md (updated: 2025-11-16)

✅ Constitutional Governance: Enabled

📄 Specifications: 3 documents
Latest specs:
- auth-requirements.md
- auth-design.md
- auth-tasks.md

💡 Next steps:
- Review steering files in steering/
- Create requirements: /sdd-requirements [feature]
- Validate compliance: itda validate
`

#### itda validate

Performs quick constitutional compliance checks:

- Article I: Library-First Principle (checks lib/ directory)
- Article II: CLI Interface Mandate (checks for cli.ts files)
- Article IV: EARS Requirements Format (validates EARS patterns)
- Article VI: Project Memory (checks steering files)

For comprehensive validation, use your agent's /sdd-validate (or equivalent) command.

$3

#### Claude Code

`bash


Generate project memory

- "Review my code" → code-reviewer skill
- "Create requirements for user login" → requirements-analyst skill
- "Design API for payment" → api-designer skill

#### GitHub Copilot

`bash


Use # prefix for custom prompts

`bash


Use / prefix for commands (TOML format)

Note: Gemini CLI commands are defined in TOML format (.toml files) instead of Markdown.

#### Cursor IDE, Qwen Code, Windsurf

`bash


Use / prefix for commands (Markdown format)

`bash


Use /prompts: prefix

- Claude Code: Skills API (automatic invocation) + 5 built-in orchestrator skills
- GitHub Copilot & Cursor: AGENTS.md (official support, reference via @agent-name)
- Gemini, Windsurf, Codex, Qwen: AGENTS.md (compatible format, natural language reference)

$3

- orchestrator - Master coordinator for multi-skill workflows
- steering - Project memory manager (auto-updating context)
- constitution-enforcer - Governance validation (9 Articles + Phase -1 Gates)

#### Built-in Orchestrator Skills (v5.9.0)

- release-manager - CHANGELOG generation, version management
- workflow-mode-manager - Mode detection (small/medium/large)
- package-manager - Monorepo package & dependency analysis
- constitution-level-manager - Level-aware validation (critical/advisory/flexible)
- project-config-manager - Schema validation & migration

$3

- requirements-analyst - EARS format requirements generation
- project-manager - Project planning, scheduling, risk management
- change-impact-analyzer - Brownfield change analysis

$3

- system-architect - C4 model + ADR architecture design
- api-designer - REST/GraphQL/gRPC API design
- database-schema-designer - Database design, ER diagrams, DDL
- ui-ux-designer - UI/UX design, wireframes, prototypes

$3

- software-developer - Multi-language code implementation

$3

- test-engineer - Unit, integration, E2E testing with EARS mapping
- code-reviewer - Code review, SOLID principles
- bug-hunter - Bug investigation, root cause analysis
- quality-assurance - QA strategy, test planning
- traceability-auditor - Requirements ↔ Code ↔ Test coverage validation

$3

- security-auditor - OWASP Top 10, vulnerability detection
- performance-optimizer - Performance analysis, optimization

$3

- devops-engineer - CI/CD pipelines, Docker/Kubernetes
- cloud-architect - AWS/Azure/GCP, IaC (Terraform/Bicep)
- database-administrator - Database operations, tuning
- site-reliability-engineer - Production monitoring, SLO/SLI, incident response
- release-coordinator - Multi-component release management

$3

- technical-writer - Technical documentation, API docs
- ai-ml-engineer - ML model development, MLOps

Governance Articles

ITDA enforces 9 immutable constitutional articles:

1. Library-First Principle - Features start as libraries
2. CLI Interface Mandate - All libraries expose CLI
3. Test-First Imperative - Tests before code (Red-Green-Blue)
4. EARS Requirements Format - Unambiguous requirements
5. Traceability Mandate - 100% coverage required
6. Project Memory - All skills check steering first
7. Simplicity Gate - Maximum 3 projects initially
8. Anti-Abstraction Gate - Use framework features directly
9. Integration-First Testing - Real services over mocks

SDD Workflow (8 Stages)

`text
1. Research → 2. Requirements → 3. Design → 4. Tasks →
5. Implementation → 6. Testing → 7. Deployment → 8. Monitoring
`

Each stage has:

- Dedicated skills
- Quality gates
- Traceability requirements
- Constitutional validation

EARS Requirements Format

`markdown


$3

WHEN user provides valid credentials,
THEN the system SHALL authenticate the user
AND the system SHALL create a session.

#### Scenario: Successful login

- WHEN user enters correct email and password
- THEN system SHALL verify credentials
- AND system SHALL redirect to dashboard
`

Bilingual Documentation

All agent-generated documents are created in both English and Korean.

$3

- English: Reference/source documents (.md)
- Korean: Translations (.ko.md)
- Skills: Always read English versions for work
- Code References: Requirement IDs, technical terms stay in English

$3

Steering Context:

- steering/structure.md + steering/structure.ko.md
- steering/tech.md + steering/tech.ko.md
- steering/product.md + steering/product.ko.md

Specifications:

- storage/specs/auth-requirements.md + storage/specs/auth-requirements.ko.md
- storage/design/auth-design.md + storage/design/auth-design.ko.md
- storage/tasks/auth-tasks.md + storage/tasks/auth-tasks.ko.md

$3

1. English version generated FIRST (reference/source)
2. Korean version generated SECOND (translation)
3. Technical terms (REQ-XXX-NNN, EARS keywords, API endpoints) remain in English
4. Both versions maintained in sync

Delta Specifications (Brownfield)

`markdown


ADDED Requirements

$3

...

MODIFIED Requirements

$3

Previous: Email + password
Updated: Email + password + OTP
...

REMOVED Requirements

$3

Reason: Security policy change
`

Example Usage

$3

`bash


1. Initialize

`bash


1. Initialize with existing codebase

`bash


Install CodeGraph MCP with pipx (--force ensures latest version)

`bash
# --force ensures latest version even if already installed
pipx install --force codegraph-mcp-server
`

2. Configure VS Code (.vscode/mcp.json):

`json
{
"servers": {
"codegraph": {
"type": "stdio",
"command": "codegraph-mcp",
"args": ["serve", "--repo", "${workspaceFolder}"]
}
}
}
`

3. Or use Claude Desktop config (~/.claude/claude_desktop_config.json on macOS/Linux, %APPDATA%\Claude\claude_desktop_config.json on Windows):

`json
{
"mcpServers": {
"codegraph": {
"command": "codegraph-mcp",
"args": ["serve", "--repo", "/path/to/your/project"]
}
}
}
`

#### Option 3: npx (No Installation)

`bash


Add via npx (no global install needed)

`text
Use the init_graph tool to analyze this codebase
`

If successful, you'll see the code graph initialization output.

Available MCP Tools (14 tools):

| Category | Tools | Description |
| ---------- | --------------------------------------------------------------------- | -------------------------------- |
| Code Graph | init_graph, get_code_snippet, find_callers, find_dependencies | Build and query code graph |
| Search | local_search, global_search, query_codebase | GraphRAG-powered semantic search |
| Analysis | analyze_module_structure, suggest_refactoring | Code structure analysis |
| Navigation | jump_to_definition, find_implementations | Code navigation |

Agent × MCP Tool Mapping:

| Agent | Primary MCP Tools | Use Case |
| ----------------------- | ------------------------------------------- | -------------------------------- |
| @change-impact-analyzer | find_dependencies, find_callers | Impact analysis |
| @traceability-auditor | query_codebase, find_callers | Traceability validation |
| @system-architect | analyze_module_structure, global_search | Architecture analysis |
| @code-reviewer | suggest_refactoring, get_code_snippet | Code quality review |
| @security-auditor | find_callers, query_codebase | Security vulnerability detection |

Also integrates with other MCP servers:

- Context7 MCP - Up-to-date library documentation (Next.js, React, etc.)
- Azure MCP - Azure resource management
- Microsoft Learn MCP - Microsoft documentation

Skills automatically use available MCP servers when needed.

$3

Edit steering files to customize for your project:

`bash


Architecture patterns

1. Fork the repository
2. Create a feature branch: git checkout -b feature/your-feature
3. Make your changes
4. Run tests locally: npm test
5. Run lint: npm run lint
6. Commit with conventional commits: git commit -m "feat: add new feature"
7. Push to your fork: git push origin feature/your-feature
8. Create a Pull Request
9. Wait for CI checks to pass (all checks must succeed)
10. Request review
11. Merge after approval

$3

- CI: Runs on every PR and push to main
- ESLint & Prettier
- Jest Tests (80% coverage required)
- Build Verification
- Security Audit
- Platform Initialization Tests (7 platforms)
- Release: Automated npm publish on version tags (v..*)
- Dependabot: Weekly dependency updates (Mondays 9:00 KST)

$3

`bash


Clone repository

Contributing

Contributions welcome! See CONTRIBUTING.md for guidelines.

⭐ Support

If you find ITDA useful, please consider:

- ⭐ Star this repository - It helps others discover ITDA
- 🐛 Report issues - Help us improve
- 💡 Suggest features - We value your ideas
- 📝 Share your experience - Write about ITDA on your blog

License

MIT License - see LICENSE for details.

Credits

ITDA synthesizes features from:

- itdda - 20-agent system, steering, EARS format
- OpenSpec - Delta specs, brownfield support
- ag2 (AutoGen) - Multi-agent orchestration
- ai-dev-tasks - Simplicity, progressive complexity
- k-sdd - P-label parallelization, validation gates
- spec-kit - Constitutional governance, test-first

📚 Learn More

- 📖 Documentation
- 📋 SRS v3.0.0
- 📅 Project Plan v3.0.0
- 🏗️ Blueprint
- 📊 Project Plan

---