aios-core 4.2.14 → 4.3.0

package/.aios-core/development/tasks/analyze-project-structure.md

@@ -556,6 +556,54 @@ After this analysis:
 
 ---
 
+### Step 5.5: Code Intelligence: Dependency & Complexity (Optional — Auto-skip if unavailable)
+
+> **Condition:** Only execute if `isCodeIntelAvailable()` returns true.
+> If no code intelligence provider is available, skip this step silently and proceed to Step 6.
+
+When code intelligence is available, enrich the analysis with real dependency and complexity data:
+
+```javascript
+const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+const { getDependencyGraph, getComplexityAnalysis } = require('.aios-core/core/code-intel/helpers/planning-helper');
+
+if (isCodeIntelAvailable()) {
+  const depGraph = await getDependencyGraph(projectPath);
+  const complexity = await getComplexityAnalysis(serviceEntryPoints);
+
+  // Add to project-analysis.md:
+  // - depGraph.dependencies: real module dependency graph
+  // - depGraph.summary: { totalDeps, depth }
+  // - complexity.perFile: complexity score per file
+  // - complexity.average: average complexity across analyzed files
+}
+```
+
+**If data is available, add these sections to the analysis documents:**
+
+**Dependency Graph (Code Intelligence):**
+
+| Metric | Value |
+|--------|-------|
+| Total Dependencies | {{depGraph.summary.totalDeps}} |
+| Dependency Depth | {{depGraph.summary.depth}} |
+
+{{depGraph.dependencies key relationships}}
+
+**Complexity Metrics (Code Intelligence):**
+
+| File | Complexity Score |
+|------|-----------------|
+{{for each complexity.perFile}}
+| {{file}} | {{complexity.score}} |
+{{end for}}
+
+**Average Complexity:** {{complexity.average}}
+
+> **Note:** These metrics are from real code analysis, not estimates.
+
+---
+
 ### Step 6: Present Results
 
 Display summary to user:

package/.aios-core/development/tasks/brownfield-create-epic.md

@@ -55,6 +55,47 @@ const architectureShardedLocation = config.architectureShardedLocation || 'docs/
 
 ## Instructions
 
+### 0. Code Intelligence: Codebase Overview (Optional — Auto-skip if unavailable)
+
+> **Condition:** Only execute if `isCodeIntelAvailable()` returns true.
+> If no code intelligence provider is available, skip this step silently and proceed to Step 1.
+
+When code intelligence is available, enrich the epic with real codebase data:
+
+```javascript
+const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+const { getCodebaseOverview, getDependencyGraph } = require('.aios-core/core/code-intel/helpers/planning-helper');
+
+if (isCodeIntelAvailable()) {
+  const overview = await getCodebaseOverview('.');
+  const depGraph = await getDependencyGraph('.');
+
+  // Include in epic under "Codebase Intelligence" section:
+  // - overview.codebase: project patterns, file groups
+  // - overview.stats: file counts, language distribution
+  // - depGraph.dependencies: module relationships
+  // - depGraph.summary: { totalDeps, depth }
+}
+```
+
+**If data is available, add this section to the epic:**
+
+#### Codebase Intelligence
+
+| Metric | Value |
+|--------|-------|
+| Project Overview | {{overview.codebase summary}} |
+| File Statistics | {{overview.stats}} |
+| Dependency Depth | {{depGraph.summary.depth}} |
+| Total Dependencies | {{depGraph.summary.totalDeps}} |
+
+**Dependency Graph Summary:**
+{{depGraph.dependencies key relationships}}
+
+> **Note:** This section is auto-generated from code intelligence. Values are real codebase data, not estimates.
+
+---
+
 ### 1. Project Analysis (Required)
 
 Before creating the epic, gather essential information about the existing project:

package/.aios-core/development/tasks/create-doc.md

@@ -250,6 +250,50 @@ If a YAML Template has not been provided, list all templates from .aios-core/pro
 
 **NEVER ask yes/no questions or use any other format.**
 
+## Code Intelligence: Codebase Intelligence Section (Optional — Auto-skip if unavailable)
+
+> **Condition:** Only execute if `isCodeIntelAvailable()` returns true AND the document being created is a PRD or architecture document.
+> If no code intelligence provider is available, skip this enhancement silently.
+
+When creating PRDs or architecture documents with code intelligence available, add a "Codebase Intelligence" section:
+
+```javascript
+const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+const { getCodebaseOverview, getDependencyGraph } = require('.aios-core/core/code-intel/helpers/planning-helper');
+
+if (isCodeIntelAvailable()) {
+  const overview = await getCodebaseOverview('.');
+  const depGraph = await getDependencyGraph('.');
+
+  // Add optional section to generated document:
+  // - overview.codebase: project patterns, file groups, architecture
+  // - overview.stats: file counts, language distribution, LOC
+  // - depGraph.summary: { totalDeps, depth }
+}
+```
+
+**If data is available, append this section to the generated document:**
+
+```markdown
+## Codebase Intelligence
+
+> Auto-generated from code intelligence provider. Real codebase data, not estimates.
+
+### Project Overview
+{{overview.codebase summary — patterns, file groups, architecture}}
+
+### Statistics
+{{overview.stats — file counts, language distribution}}
+
+### Dependency Summary
+- **Total Dependencies:** {{depGraph.summary.totalDeps}}
+- **Dependency Depth:** {{depGraph.summary.depth}}
+```
+
+> **Note:** This section is optional and only appears when a code intelligence provider is available. The document is fully functional without it.
+
+---
+
 ## Processing Flow
 
 1. **Parse YAML template** - Load template metadata and sections

package/.aios-core/development/tasks/create-next-story.md

@@ -239,6 +239,16 @@ To identify the next logical story based on project progress and epic definition
 - **If no story files exist:** The next story is ALWAYS 1.1 (first story of first epic)
 - Announce the identified story to the user: "Identified next story for preparation: {epicNum}.{storyNum} - {Story Title}"
 
+### 1.2 Code Intelligence: Duplicate Detection & File Suggestions (Auto-skip if unavailable)
+
+- **Check code intelligence availability:** Call `isCodeIntelAvailable()` from `.aios-core/core/code-intel`
+- **If available:**
+  - Call `detectDuplicateStory(storyDescription)` from `.aios-core/core/code-intel/helpers/story-helper`
+    - If matches found: Display advisory warning to user — "Similar functionality found: {warning}". This is **advisory only** and does NOT block story creation.
+  - Call `suggestRelevantFiles(storyDescription)` from `.aios-core/core/code-intel/helpers/story-helper`
+    - If files found: Pre-populate a "Suggested Files" note in the Dev Notes section with the relevant file references
+- **If NOT available:** Skip this step silently — story creation proceeds exactly as before
+
 ### 2. Gather Story Requirements and Previous Story Context
 
 - Extract story requirements from the identified epic file

package/.aios-core/development/tasks/dev-develop-story.md

@@ -559,7 +559,7 @@ Execute **AFTER** all tasks are complete but **BEFORE** running the DOD checklis
 │  WHILE iteration < max_iterations:                           │
 │    ┌────────────────────────────────────────────────────┐   │
 │    │ 1. Run CodeRabbit CLI                              │   │
-│    │    wsl bash -c 'cd /mnt/c/.../@synkra/aios-core &&    │   │
+│    │    wsl bash -c 'cd /mnt/c/.../aios-core &&    │   │
 │    │    ~/.local/bin/coderabbit --prompt-only           │   │
 │    │    -t uncommitted'                                  │   │
 │    │                                                     │   │

package/.aios-core/development/tasks/github-devops-github-pr-automation.md

@@ -501,6 +501,55 @@ function generatePRDescription(storyInfo, context) {
 }
 ```
 
+### Step 5.1: Enrich PR Description with Impact Analysis (Code Intelligence — Advisory)
+
+> **Added by:** Story NOG-7 (DevOps Pre-Push Impact Analysis)
+> **Behavior:** Auto-skips if code intelligence unavailable. Appends "Impact Analysis" section to PR body.
+
+```javascript
+const { generateImpactSummary } = require('.aios-core/core/code-intel/helpers/devops-helper');
+
+async function enrichPRWithImpactAnalysis(description, changedFiles) {
+  // Auto-skip if code intelligence unavailable
+  const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+  if (!isCodeIntelAvailable()) {
+    return description; // Return original description unchanged
+  }
+
+  const impact = await generateImpactSummary(changedFiles);
+
+  if (!impact) {
+    return description; // No impact data — return original
+  }
+
+  // Append Impact Analysis section to PR description
+  const impactSection = [
+    '',
+    '## Impact Analysis',
+    '',
+    impact.summary,
+    '',
+    '---',
+    '*Generated by Code Intelligence (advisory only)*',
+  ].join('\n');
+
+  return description + impactSection;
+}
+```
+
+**Usage in PR creation flow:**
+
+After `generatePRDescription()` returns the base description, call `enrichPRWithImpactAnalysis()` to optionally append the impact section:
+
+```javascript
+let description = generatePRDescription(storyInfo, context);
+description = await enrichPRWithImpactAnalysis(description, changedFiles);
+```
+
+**Important:** If code intelligence is unavailable or returns null, the PR description remains unchanged — zero impact on existing workflow.
+
+---
+
 ### Step 6: Determine Base Branch
 
 ```javascript

package/.aios-core/development/tasks/github-devops-pre-push-quality-gate.md

@@ -630,6 +630,64 @@ function determineSecurityGate(results) {
 }
 ```
 
+### 9.1 Impact Analysis (Code Intelligence — Advisory Only)
+
+> **Added by:** Story NOG-7 (DevOps Pre-Push Impact Analysis)
+> **Behavior:** Advisory only — NEVER blocks push. Auto-skips if code intelligence unavailable.
+
+```javascript
+const { assessPrePushImpact, classifyRiskLevel } = require('.aios-core/core/code-intel/helpers/devops-helper');
+
+async function runImpactAnalysis(changedFiles) {
+  // Auto-skip if code intelligence unavailable
+  const { isCodeIntelAvailable } = require('.aios-core/core/code-intel');
+  if (!isCodeIntelAvailable()) {
+    console.log('ℹ️  Code intelligence not available — skipping impact analysis');
+    return { skipped: true };
+  }
+
+  console.log('\n📊 Running Impact Analysis...\n');
+
+  const result = await assessPrePushImpact(changedFiles);
+
+  if (!result) {
+    console.log('ℹ️  Impact analysis returned no data — skipping');
+    return { skipped: true };
+  }
+
+  // Display formatted report
+  console.log(result.report);
+
+  // HIGH risk: add extra warning (advisory, does not block)
+  if (result.riskLevel === 'HIGH') {
+    console.log('\n⚠️  HIGH RISK detected. Additional confirmation recommended before push.');
+  }
+
+  return {
+    skipped: false,
+    riskLevel: result.riskLevel,
+    blastRadius: result.impact ? result.impact.blastRadius : 0,
+    report: result.report,
+  };
+}
+```
+
+**Integration with Summary Report:**
+
+Add impact analysis results to the summary report section:
+
+```
+Impact Analysis:
+  📊 Blast Radius: {N} files affected
+  📊 Risk Level: {LOW|MEDIUM|HIGH}
+  {if HIGH: ⚠️  HIGH RISK: {N} files affected. Confirm push?}
+  {if skipped: ℹ️  Skipped (code intelligence not available)}
+```
+
+**Important:** This step is purely advisory. A HIGH risk level does NOT change the overall gate status from PASS to FAIL. It only adds an informational warning and may prompt additional user confirmation.
+
+---
+
 ### 10. Verify Story Status (Optional - if using story-driven workflow)
 
 ```javascript
@@ -684,6 +742,11 @@ Quality Checks:
   ✓ Security scan        PASSED
   ⚠️ Story status         SKIPPED (no story file)
 
+Impact Analysis (Advisory):
+  📊 Blast Radius: {N} files affected
+  📊 Risk Level: LOW | MEDIUM | HIGH
+  ℹ️  Advisory only — does not affect gate status
+
 Security Scan Results:
   ✓ Dependencies: 0 critical, 0 high, 2 moderate, 5 low
   ✓ Code patterns: No security issues

package/.aios-core/development/tasks/github-issue-triage.md

@@ -0,0 +1,118 @@
+# GitHub Issue Triage
+
+## Task Metadata
+
+```yaml
+id: github-issue-triage
+name: GitHub Issue Triage
+agent: devops
+elicit: true
+category: repository-management
+story: GHIM-001
+```
+
+## Description
+
+Systematic triage of GitHub issues for the aios-core repository. This task guides @devops through the process of reviewing, classifying, and labeling open issues.
+
+## Prerequisites
+
+- GitHub CLI authenticated (`gh auth status`)
+- Label taxonomy deployed (see GHIM-001 Phase 1)
+- Access to repository issue list
+
+## Workflow
+
+### Step 1: List Untriaged Issues
+
+```bash
+gh issue list --label "status: needs-triage" --json number,title,labels,createdAt,author --limit 50
+```
+
+### Step 2: Per-Issue Triage (Interactive)
+
+For each issue, apply the triage checklist:
+
+1. **Read the issue** — Open and understand the content
+2. **Classify type** — Apply ONE `type:` label:
+   - `type: bug` — Something isn't working
+   - `type: feature` — New feature request
+   - `type: enhancement` — Improvement to existing feature
+   - `type: docs` — Documentation issue
+   - `type: test` — Test coverage
+   - `type: chore` — Maintenance/cleanup
+3. **Assess priority** — Apply ONE `priority:` label:
+   - `priority: P1` — Critical, blocks users (SLA: 24h response)
+   - `priority: P2` — High, affects most users (SLA: 3 days)
+   - `priority: P3` — Medium, affects some users (SLA: 1 week)
+   - `priority: P4` — Low, edge cases (backlog)
+4. **Assign area** — Apply ONE or more `area:` labels:
+   - `area: core`, `area: installer`, `area: synapse`, `area: cli`
+   - `area: pro`, `area: health-check`, `area: docs`, `area: devops`
+5. **Update status** — Replace `status: needs-triage` with appropriate status:
+   - `status: confirmed` — Valid issue, ready for work
+   - `status: needs-info` — Need more details from reporter
+6. **Check for duplicates** — If duplicate, label `duplicate` and close with reference
+7. **Community labels** — If appropriate, add `community: good first issue` or `community: help wanted`
+
+### Step 3: Apply Labels
+
+```bash
+gh issue edit {number} --add-label "type: bug,priority: P2,area: installer,status: confirmed" --remove-label "status: needs-triage"
+```
+
+### Step 4: Batch Triage (Optional)
+
+For bulk operations, use the triage script:
+
+```bash
+node .aios-core/development/scripts/issue-triage.js --list
+node .aios-core/development/scripts/issue-triage.js --apply {number} --type bug --priority P2 --area installer
+```
+
+### Step 5: Report
+
+After triage session, generate summary:
+
+```bash
+node .aios-core/development/scripts/issue-triage.js --report
+```
+
+## Triage Decision Tree
+
+```
+Issue received
+  ├── Is it a duplicate? → Label "duplicate", close with reference
+  ├── Is it spam/invalid? → Label "status: invalid", close
+  ├── Needs more info? → Label "status: needs-info", comment asking for details
+  └── Valid issue
+       ├── Bug → "type: bug" + priority + area
+       ├── Feature → "type: feature" + priority + area
+       ├── Enhancement → "type: enhancement" + priority + area
+       ├── Docs → "type: docs" + priority: P3/P4
+       └── Tests → "type: test" + area
+```
+
+## Priority Guidelines
+
+| Signal | Priority |
+|--------|----------|
+| Blocks installation/usage for all users | P1 |
+| Breaks core functionality, no workaround | P1 |
+| Significant bug with workaround | P2 |
+| Feature highly requested by community | P2 |
+| Minor bug, edge case | P3 |
+| Nice-to-have improvement | P3 |
+| Cosmetic, low impact | P4 |
+
+## Command Integration
+
+This task is invocable via @devops:
+- `*triage` — Start interactive triage session
+- `*triage --batch` — Run batch triage with script
+
+## Output
+
+- All issues labeled with `type:`, `priority:`, `area:` labels
+- `status: needs-triage` removed from all triaged issues
+- Triage report with summary of actions taken