feat: Add role specifications for 三省六部 architecture

- Introduced role specifications for 尚书省 (shangshu), 刑部 (xingbu), and 中书省 (zhongshu) to facilitate task management and execution flow.
- Implemented quality gates for each phase of the process to ensure compliance and quality assurance.
- Established a coordinator role to manage the overall workflow and task distribution among the departments.
- Created a team configuration file to define roles, responsibilities, and routing rules for task execution.
- Added localization support for DeepWiki in both English and Chinese, enhancing accessibility for users.
This commit is contained in:
catlog22
2026-03-06 11:26:27 +08:00
parent 56c06ecf3d
commit 33cc451b61
46 changed files with 3050 additions and 1832 deletions

View File

@@ -0,0 +1,224 @@
# Phase 1: Functional Analysis
Read target file, extract functional inventory with code block classification, identify redundancy, validate pseudo-code format, and produce optimization plan.
## Objective
- Build quantitative functional inventory with code block classification (baseline for Phase 3)
- Identify redundancy categories with specific line ranges
- Detect pseudo-code format issues
- Produce optimization plan with estimated line savings
## Execution
### Step 1.1: Read & Measure Target
```javascript
const originalContent = Read(targetFile)
const lines = originalContent.split('\n')
const originalLineCount = lines.length
```
### Step 1.2: Extract Functional Inventory
Count and catalog every functional element. These counts are the **baseline** for Phase 3 verification.
```javascript
const inventory = {
// Code structures — with role classification
codeBlocks: [], // { startLine, endLine, language, purpose, role: 'functional'|'descriptive' }
agentCalls: [], // { line, agentType, description, mergeGroup?: string }
dataStructures: [], // { line, name, type: 'object'|'array'|'schema' }
// Logic elements
routingBranches: [], // { line, condition, outcomes[] }
errorHandlers: [], // { line, errorType, resolution }
conditionalLogic: [], // { line, condition, trueAction, falseAction }
// Interface elements
askUserQuestions: [], // { line, questionCount, headers[], optionType: 'static'|'dynamic' }
inputModes: [], // { line, mode, description }
outputArtifacts: [], // { line, artifact, format }
// Structural elements
todoWriteBlocks: [], // { line, phaseCount }
phaseHandoffs: [], // { line, fromPhase, toPhase }
skillInvocations: [], // { line, skillName, hasExecutionSteps: boolean }
// Reference elements
tables: [], // { startLine, endLine, columns }
schemas: [], // { line, schemaName, fields[] }
// Format issues
formatIssues: [], // { line, type, description, severity: 'error'|'warning' }
// Totals (computed)
counts: {}
}
```
**Extraction rules**:
- **Code blocks**: Match ` ```language ... ``` ` pairs, record start/end/language/first-line-as-purpose
- **Agent calls**: Match `Agent(`, `Task(`, `subagent_type=`, record type and prompt summary
- **Data structures**: Match `const xxx = {`, `const xxx = [`, JSON schema objects
- **Routing branches**: Match `if/else`, `switch/case`, ternary `? :` with meaningful branching
- **Error handlers**: Match `catch`, error table rows `| Error |`, fallback patterns
- **AskUserQuestion**: Match `AskUserQuestion({`, count questions array length
- **Input modes**: Match `Mode 1/2/3`, `--flag`, argument parsing
- **Output artifacts**: Match `Write(`, `Output:`, file path patterns in comments
- **TodoWrite**: Match `TodoWrite({`, count todo items
- **Phase handoffs**: Match `Read("phases/`, `Skill(`, `proceed_to_next_phase`
- **Tables**: Match `| header |` markdown table blocks
- **Schemas**: Match schema references, JSON structure definitions
### Step 1.2.1: Code Block Role Classification
For each code block, determine its role:
| Role | Criteria | Examples |
|------|----------|---------|
| `functional` | Contains algorithm logic, routing branches, conditional code, agent calls, schema definitions, data processing, AskUserQuestion, Skill invocations | `if/else`, `Agent({...})`, `const schema = {...}`, `Bash({...})` |
| `descriptive` | Contains ASCII art, usage examples, display templates, illustrative good/bad comparisons, folder structure trees | `┌───┐`, `# Example usage`, `❌ Bad / ✅ Good`, `├── file.ts` |
**Classification rules**:
- If block contains ANY of: `Agent(`, `Bash(`, `AskUserQuestion(`, `if (`, `switch`, `Skill(`, `Write(`, `Read(`, `TodoWrite(``functional`
- If block language is `bash` and content is only example invocations (no logic) → `descriptive`
- If block has no language tag and contains only ASCII box-drawing characters → `descriptive`
- If block is labeled as "Example" in surrounding markdown heading → `descriptive`
- **Default**: `functional` (conservative)
### Step 1.2.2: Pseudo-Code Format Validation
Scan all `functional` code blocks for format issues:
| Check | Detection | Severity |
|-------|-----------|----------|
| **Nested backticks** | Template literal `` ` `` inside ` ```javascript ``` ` code fence | warning |
| **Unclosed brackets** | Unmatched `{`, `(`, `[` in code block | error |
| **Undefined references** | `${variable}` where variable is never declared in the block or prior blocks | warning |
| **Inconsistent indentation** | Mixed tabs/spaces or inconsistent nesting depth | warning |
| **Dead code patterns** | Commented-out code blocks (`// if (`, `/* ... */` spanning 5+ lines) | warning |
| **Missing return/output** | Function-like block with no return, Write, or console.log | warning |
```javascript
inventory.formatIssues = validatePseudoCode(inventory.codeBlocks.filter(b => b.role === 'functional'))
```
### Step 1.2.3: Compute Totals
```javascript
inventory.counts = {
codeBlocks: inventory.codeBlocks.length,
functionalCodeBlocks: inventory.codeBlocks.filter(b => b.role === 'functional').length,
descriptiveCodeBlocks: inventory.codeBlocks.filter(b => b.role === 'descriptive').length,
agentCalls: inventory.agentCalls.length,
dataStructures: inventory.dataStructures.length,
routingBranches: inventory.routingBranches.length,
errorHandlers: inventory.errorHandlers.length,
conditionalLogic: inventory.conditionalLogic.length,
askUserQuestions: inventory.askUserQuestions.length,
inputModes: inventory.inputModes.length,
outputArtifacts: inventory.outputArtifacts.length,
todoWriteBlocks: inventory.todoWriteBlocks.length,
phaseHandoffs: inventory.phaseHandoffs.length,
skillInvocations: inventory.skillInvocations.length,
tables: inventory.tables.length,
schemas: inventory.schemas.length,
formatIssues: inventory.formatIssues.length
}
```
### Step 1.3: Identify Redundancy Categories
Scan for each category, record specific line ranges:
```javascript
const redundancyMap = {
deletable: [], // { category, startLine, endLine, reason, estimatedSave }
simplifiable: [], // { category, startLine, endLine, strategy, estimatedSave }
mergeable: [], // { items: [{startLine, endLine}], mergeStrategy, estimatedSave }
formatFixes: [], // { line, type, fix }
languageUnify: [] // { line, currentLang, targetLang }
}
```
**Deletable** (remove entirely, no functional loss):
| Pattern | Detection |
|---------|-----------|
| Duplicate Overview | `## Overview` that restates frontmatter description |
| ASCII flowchart | Flowchart that duplicates Phase Summary table or implementation structure |
| "When to use" section | Usage guidance not needed for execution |
| Best Practices section | Advisory content duplicating Core Rules |
| Duplicate examples | Code examples that repeat logic shown elsewhere |
| Folder structure duplicate | ASCII tree repeating Output Artifacts table |
| "Next Phase" paragraphs | Prose between phases when TodoWrite handles flow |
| Descriptive code blocks | Code blocks classified as `descriptive` whose content is covered by surrounding prose or tables |
**Simplifiable** (compress, preserve meaning):
| Pattern | Strategy |
|---------|----------|
| Verbose comments in code blocks | Reduce to single-line; keep only non-obvious logic comments |
| Multi-line console.log | Compress to single template literal |
| Wordy section intros | Remove "In this phase, we will..." preamble |
| Exploration prompt bloat | Trim to essential instructions, remove generic advice |
| Display-format code blocks | Convert code blocks that only define output format (console.log with template) to prose description |
**Mergeable** (combine related structures):
| Pattern | Strategy |
|---------|----------|
| Multiple similar AskUserQuestion calls | Extract shared function with mode parameter |
| Repeated Option routing | Unify into single dispatch |
| Sequential single-line operations | Combine into one code block |
| TodoWrite full blocks x N | Template once + delta comments |
| Duplicate error handling tables | Merge into single table |
| Equivalent template variants | Single/multi-perspective templates → one template with variant comment |
| Multiple output artifact tables | Merge into single combined table |
**Format fixes** (pseudo-code quality):
| Pattern | Fix |
|---------|-----|
| Nested backtick template literals | Convert surrounding code block to prose description, or use 4-backtick fence |
| Hardcoded option lists | Add comment: `// Generate dynamically from {context source}` |
| Workflow handoff without execution steps | Add execution steps referencing the target command's actual interface |
| Unclosed brackets | Fix bracket matching |
**Language unification**:
- Detect mixed Chinese/English in functional comments
- Recommend consistent language (match majority)
### Step 1.4: Build Optimization Plan
```javascript
const optimizationPlan = {
targetFile,
originalLineCount,
estimatedReduction: redundancyMap.deletable.reduce((s, d) => s + d.estimatedSave, 0)
+ redundancyMap.simplifiable.reduce((s, d) => s + d.estimatedSave, 0)
+ redundancyMap.mergeable.reduce((s, d) => s + d.estimatedSave, 0),
categories: {
deletable: { count: redundancyMap.deletable.length, totalLines: '...' },
simplifiable: { count: redundancyMap.simplifiable.length, totalLines: '...' },
mergeable: { count: redundancyMap.mergeable.length, totalLines: '...' },
formatFixes: { count: redundancyMap.formatFixes.length },
languageUnify: { count: redundancyMap.languageUnify.length }
},
// Ordered: delete → merge → simplify → format
operations: [
...redundancyMap.deletable.map(d => ({ type: 'delete', ...d, priority: 1 })),
...redundancyMap.mergeable.map(m => ({ type: 'merge', ...m, priority: 2 })),
...redundancyMap.simplifiable.map(s => ({ type: 'simplify', ...s, priority: 3 })),
...redundancyMap.formatFixes.map(f => ({ type: 'format', ...f, priority: 4 }))
]
}
```
Display plan summary: category counts, estimated reduction percentage, sections NOT changed (functional core).
## Output
- **Variable**: `analysisResult = { inventory, redundancyMap, optimizationPlan, originalContent, originalLineCount }`
- **TodoWrite**: Mark Phase 1 completed, Phase 2 in_progress