aios-core 4.2.2 → 4.2.4

package/scripts/code-intel-health-check.js

@@ -22,14 +22,14 @@
  * @agent @devops (Gage)
  */
 
-const { execFile } = require('node:child_process')
-const { promisify } = require('node:util')
-const { existsSync, readFileSync } = require('node:fs')
-const { resolve, join } = require('node:path')
+const { execFile } = require('node:child_process');
+const { promisify } = require('node:util');
+const { existsSync, readFileSync } = require('node:fs');
+const { resolve, join } = require('node:path');
 
-const execFileAsync = promisify(execFile)
+const execFileAsync = promisify(execFile);
 
-const RESPONSE_TIMEOUT_MS = 5000
+const RESPONSE_TIMEOUT_MS = 5000;
 const EXPECTED_TOOLS = [
   'get_usage_guide',
   'analyze_codebase',
@@ -39,147 +39,147 @@ const EXPECTED_TOOLS = [
   'find_callees',
   'complexity_analysis',
   'dependency_analysis',
-  'project_statistics'
-]
+  'project_statistics',
+];
 
 function parseArgs() {
-  const args = process.argv.slice(2)
+  const args = process.argv.slice(2);
   return {
     smoke: args.includes('--smoke'),
-    projectRoot: getArgValue(args, '--project-root') || process.cwd()
-  }
+    projectRoot: getArgValue(args, '--project-root') || process.cwd(),
+  };
 }
 
 function getArgValue(args, flag) {
-  const idx = args.indexOf(flag)
-  if (idx === -1 || idx + 1 >= args.length) return null
-  return args[idx + 1]
+  const idx = args.indexOf(flag);
+  if (idx === -1 || idx + 1 >= args.length) return null;
+  return args[idx + 1];
 }
 
 async function checkBinaryInstalled() {
   try {
     const { stdout } = await execFileAsync('code-graph-mcp', ['--help'], {
-      timeout: RESPONSE_TIMEOUT_MS
-    })
-    return { installed: true, output: stdout.trim() }
+      timeout: RESPONSE_TIMEOUT_MS,
+    });
+    return { installed: true, output: stdout.trim() };
   } catch (error) {
     return {
       installed: false,
       error: error.code === 'ENOENT'
         ? 'code-graph-mcp binary not found in PATH'
-        : `Binary check failed: ${error.message}`
-    }
+        : `Binary check failed: ${error.message}`,
+    };
   }
 }
 
 function checkMcpConfig(projectRoot) {
-  const mcpJsonPath = join(projectRoot, '.mcp.json')
+  const mcpJsonPath = join(projectRoot, '.mcp.json');
   if (!existsSync(mcpJsonPath)) {
-    return { configured: false, error: '.mcp.json not found' }
+    return { configured: false, error: '.mcp.json not found' };
   }
 
   try {
-    const config = JSON.parse(readFileSync(mcpJsonPath, 'utf-8'))
-    const servers = config.mcpServers || {}
-    const codeGraphEntry = servers['code-graph'] || servers['code-graph-mcp']
+    const config = JSON.parse(readFileSync(mcpJsonPath, 'utf-8'));
+    const servers = config.mcpServers || {};
+    const codeGraphEntry = servers['code-graph'] || servers['code-graph-mcp'];
 
     if (!codeGraphEntry) {
-      return { configured: false, error: 'No code-graph entry in .mcp.json mcpServers' }
+      return { configured: false, error: 'No code-graph entry in .mcp.json mcpServers' };
     }
 
     return {
       configured: true,
       serverName: servers['code-graph'] ? 'code-graph' : 'code-graph-mcp',
-      config: codeGraphEntry
-    }
+      config: codeGraphEntry,
+    };
   } catch (error) {
-    return { configured: false, error: `Failed to parse .mcp.json: ${error.message}` }
+    return { configured: false, error: `Failed to parse .mcp.json: ${error.message}` };
   }
 }
 
 async function checkServerAndTools(projectRoot) {
-  const start = Date.now()
+  const start = Date.now();
   try {
-    const child = execFile('code-graph-mcp', ['--project-root', projectRoot])
+    const child = execFile('code-graph-mcp', ['--project-root', projectRoot]);
 
     return new Promise((resolvePromise) => {
-      let stdout = ''
-      let stderr = ''
-      let settled = false
+      let stdout = '';
+      let stderr = '';
+      let settled = false;
 
       const settle = (result) => {
-        if (settled) return
-        settled = true
-        resolvePromise(result)
-      }
+        if (settled) return;
+        settled = true;
+        resolvePromise(result);
+      };
 
       child.stdout.on('data', (data) => {
-        stdout += data.toString()
-      })
+        stdout += data.toString();
+      });
 
       child.stderr.on('data', (data) => {
-        stderr += data.toString()
-      })
+        stderr += data.toString();
+      });
 
       // Send MCP initialize + tools/list via JSON-RPC over stdio
       const initMsg = JSON.stringify({
         jsonrpc: '2.0', id: 1, method: 'initialize',
-        params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'health-check', version: '1.0' } }
-      })
-      const notifyMsg = JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' })
-      const listMsg = JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} })
+        params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'health-check', version: '1.0' } },
+      });
+      const notifyMsg = JSON.stringify({ jsonrpc: '2.0', method: 'notifications/initialized' });
+      const listMsg = JSON.stringify({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} });
 
-      child.stdin.write(initMsg + '\n')
-      child.stdin.write(notifyMsg + '\n')
-      child.stdin.write(listMsg + '\n')
+      child.stdin.write(initMsg + '\n');
+      child.stdin.write(notifyMsg + '\n');
+      child.stdin.write(listMsg + '\n');
 
       // Parse JSON-RPC responses as they arrive
-      let responseCount = 0
-      let actualTools = null
+      let responseCount = 0;
+      let actualTools = null;
 
       const checkResponses = () => {
-        const lines = stdout.split('\n').filter((l) => l.trim())
+        const lines = stdout.split('\n').filter((l) => l.trim());
         for (const line of lines) {
           try {
-            const msg = JSON.parse(line)
-            if (msg.id === 1) responseCount++
+            const msg = JSON.parse(line);
+            if (msg.id === 1) responseCount++;
             if (msg.id === 2 && msg.result && msg.result.tools) {
-              responseCount++
-              actualTools = msg.result.tools.map((t) => t.name)
+              responseCount++;
+              actualTools = msg.result.tools.map((t) => t.name);
             }
           } catch {
             // partial line
           }
         }
-      }
+      };
 
       // Poll for responses, timeout after RESPONSE_TIMEOUT_MS
       const pollInterval = setInterval(() => {
-        checkResponses()
+        checkResponses();
         if (responseCount >= 2) {
-          clearInterval(pollInterval)
-          clearTimeout(timer)
-          child.kill('SIGTERM')
+          clearInterval(pollInterval);
+          clearTimeout(timer);
+          child.kill('SIGTERM');
 
           const toolReport = EXPECTED_TOOLS.map((name) => ({
             name,
-            available: actualTools ? actualTools.includes(name) : false
-          }))
+            available: actualTools ? actualTools.includes(name) : false,
+          }));
 
           settle({
             responding: true,
             responseTimeMs: Date.now() - start,
             tools: toolReport,
             actualToolCount: actualTools ? actualTools.length : 0,
-            note: 'Server responded via JSON-RPC, tools verified via tools/list'
-          })
+            note: 'Server responded via JSON-RPC, tools verified via tools/list',
+          });
         }
-      }, 200)
+      }, 200);
 
       const timer = setTimeout(() => {
-        clearInterval(pollInterval)
-        child.kill('SIGTERM')
-        checkResponses()
+        clearInterval(pollInterval);
+        child.kill('SIGTERM');
+        checkResponses();
 
         // If we got at least the init response, server is alive
         if (responseCount >= 1) {
@@ -188,59 +188,59 @@ async function checkServerAndTools(projectRoot) {
             responseTimeMs: Date.now() - start,
             tools: EXPECTED_TOOLS.map((name) => ({ name, available: true })),
             actualToolCount: EXPECTED_TOOLS.length,
-            note: 'Server responded to initialize but tools/list timed out; using expected tool list'
-          })
+            note: 'Server responded to initialize but tools/list timed out; using expected tool list',
+          });
         } else {
           settle({
             responding: false,
             responseTimeMs: Date.now() - start,
             tools: EXPECTED_TOOLS.map((name) => ({ name, available: false })),
             actualToolCount: 0,
-            error: 'Server did not respond within timeout'
-          })
+            error: 'Server did not respond within timeout',
+          });
         }
-      }, RESPONSE_TIMEOUT_MS)
+      }, RESPONSE_TIMEOUT_MS);
 
       child.on('error', (error) => {
-        clearInterval(pollInterval)
-        clearTimeout(timer)
+        clearInterval(pollInterval);
+        clearTimeout(timer);
         settle({
           responding: false,
           responseTimeMs: Date.now() - start,
           tools: EXPECTED_TOOLS.map((name) => ({ name, available: false })),
           actualToolCount: 0,
-          error: `Server failed to start: ${error.message}`
-        })
-      })
+          error: `Server failed to start: ${error.message}`,
+        });
+      });
 
       child.on('exit', (code) => {
-        clearInterval(pollInterval)
-        clearTimeout(timer)
+        clearInterval(pollInterval);
+        clearTimeout(timer);
         if (code !== null && code !== 0) {
           settle({
             responding: false,
             responseTimeMs: Date.now() - start,
             tools: EXPECTED_TOOLS.map((name) => ({ name, available: false })),
             actualToolCount: 0,
-            error: `Server exited with code ${code}. stderr: ${stderr}`
-          })
+            error: `Server exited with code ${code}. stderr: ${stderr}`,
+          });
         }
-      })
-    })
+      });
+    });
   } catch (error) {
     return {
       responding: false,
       responseTimeMs: Date.now() - start,
       tools: EXPECTED_TOOLS.map((name) => ({ name, available: false })),
       actualToolCount: 0,
-      error: `Server check failed: ${error.message}`
-    }
+      error: `Server check failed: ${error.message}`,
+    };
   }
 }
 
 async function runHealthCheck() {
-  const { smoke, projectRoot } = parseArgs()
-  const resolvedRoot = resolve(projectRoot)
+  const { smoke, projectRoot } = parseArgs();
+  const resolvedRoot = resolve(projectRoot);
 
   const report = {
     status: 'unknown',
@@ -251,64 +251,64 @@ async function runHealthCheck() {
     checks: {},
     tools: [],
     responseTimeMs: null,
-    errors: []
-  }
+    errors: [],
+  };
 
   // Check 1: Binary installed
-  const binaryCheck = await checkBinaryInstalled()
-  report.checks.binaryInstalled = binaryCheck.installed
+  const binaryCheck = await checkBinaryInstalled();
+  report.checks.binaryInstalled = binaryCheck.installed;
   if (!binaryCheck.installed) {
-    report.status = 'unavailable'
-    report.errors.push(binaryCheck.error)
-    outputReport(report, 2)
-    return
+    report.status = 'unavailable';
+    report.errors.push(binaryCheck.error);
+    outputReport(report, 2);
+    return;
   }
 
   // Check 2: MCP config present
-  const configCheck = checkMcpConfig(resolvedRoot)
-  report.checks.mcpConfigured = configCheck.configured
+  const configCheck = checkMcpConfig(resolvedRoot);
+  report.checks.mcpConfigured = configCheck.configured;
   if (!configCheck.configured) {
-    report.errors.push(configCheck.error)
+    report.errors.push(configCheck.error);
     // Not a blocker — binary works, just no MCP config
   }
 
   // Check 3: Server responds and tools verified via MCP tools/list
-  const serverCheck = await checkServerAndTools(resolvedRoot)
-  report.checks.serverResponding = serverCheck.responding
-  report.responseTimeMs = serverCheck.responseTimeMs
+  const serverCheck = await checkServerAndTools(resolvedRoot);
+  report.checks.serverResponding = serverCheck.responding;
+  report.responseTimeMs = serverCheck.responseTimeMs;
 
   if (!serverCheck.responding) {
-    report.status = 'unavailable'
-    report.errors.push(serverCheck.error)
-    report.tools = serverCheck.tools
-    outputReport(report, 2)
-    return
+    report.status = 'unavailable';
+    report.errors.push(serverCheck.error);
+    report.tools = serverCheck.tools;
+    outputReport(report, 2);
+    return;
   }
 
   // Tool report from real MCP tools/list query
-  report.tools = serverCheck.tools
-  const availableCount = report.tools.filter((t) => t.available).length
+  report.tools = serverCheck.tools;
+  const availableCount = report.tools.filter((t) => t.available).length;
 
   if (availableCount === EXPECTED_TOOLS.length) {
-    report.status = 'available'
+    report.status = 'available';
   } else if (availableCount > 0) {
-    report.status = 'degraded'
+    report.status = 'degraded';
   } else {
-    report.status = 'unavailable'
+    report.status = 'unavailable';
   }
 
   // Version detection (try pip, fallback to python -m pip for Windows compatibility)
   for (const cmd of [
     { file: 'pip', args: ['show', 'code-graph-mcp', '--no-color'] },
     { file: 'python', args: ['-m', 'pip', 'show', 'code-graph-mcp', '--no-color'] },
-    { file: 'python3', args: ['-m', 'pip', 'show', 'code-graph-mcp', '--no-color'] }
+    { file: 'python3', args: ['-m', 'pip', 'show', 'code-graph-mcp', '--no-color'] },
   ]) {
     try {
-      const { stdout } = await execFileAsync(cmd.file, cmd.args, { timeout: 5000 })
-      const versionMatch = stdout.match(/Version:\s*(.+)/)
+      const { stdout } = await execFileAsync(cmd.file, cmd.args, { timeout: 5000 });
+      const versionMatch = stdout.match(/Version:\s*(.+)/);
       if (versionMatch) {
-        report.version = versionMatch[1].trim()
-        break
+        report.version = versionMatch[1].trim();
+        break;
       }
     } catch {
       // Try next command
@@ -323,21 +323,21 @@ async function runHealthCheck() {
         'Use find_definition tool with symbol "UnifiedActivationPipeline"',
         'Use find_references tool with symbol "entity-registry"',
         'Use dependency_analysis tool on ".aios-core/core/"',
-        'Use project_statistics tool on project root'
-      ]
-    }
+        'Use project_statistics tool on project root',
+      ],
+    };
   }
 
   const exitCode = report.status === 'available' ? 0
     : report.status === 'degraded' ? 1
-    : 2
+      : 2;
 
-  outputReport(report, exitCode)
+  outputReport(report, exitCode);
 }
 
 function outputReport(report, exitCode) {
-  console.log(JSON.stringify(report, null, 2))
-  process.exit(exitCode)
+  console.log(JSON.stringify(report, null, 2));
+  process.exit(exitCode);
 }
 
-runHealthCheck()
+runHealthCheck();

package/scripts/ensure-manifest.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+'use strict';
+
+const { execSync } = require('child_process');
+const { validateManifest } = require('./validate-manifest');
+const { generateManifest, writeManifest } = require('./generate-install-manifest');
+
+function getStagedFiles() {
+  try {
+    const output = execSync('git diff --cached --name-only', { encoding: 'utf8' }).trim();
+    if (!output) return [];
+    return output.split('\n').map((line) => line.trim()).filter(Boolean);
+  } catch (_error) {
+    return [];
+  }
+}
+
+function shouldCheckManifest(stagedFiles) {
+  if (stagedFiles.length === 0) return false;
+
+  return stagedFiles.some((file) => {
+    if (file === '.aios-core/install-manifest.yaml') return false;
+    return file.startsWith('.aios-core/');
+  });
+}
+
+async function main() {
+  const stagedFiles = getStagedFiles();
+  if (!shouldCheckManifest(stagedFiles)) {
+    console.log('ℹ️ manifest: no .aios-core changes staged, skipping check');
+    return;
+  }
+
+  const result = validateManifest();
+  if (result.valid) {
+    console.log('✅ manifest: already up-to-date');
+    return;
+  }
+
+  console.log('🔄 manifest: outdated, regenerating...');
+  const manifest = await generateManifest();
+  await writeManifest(manifest);
+  execSync('git add .aios-core/install-manifest.yaml', { stdio: 'inherit' });
+  console.log('✅ manifest: regenerated and staged');
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(`❌ manifest: ensure failed - ${error.message}`);
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  getStagedFiles,
+  shouldCheckManifest,
+  main,
+};

package/.aios-core/infrastructure/scripts/ide-sync/transformers/windsurf.js

@@ -1,106 +0,0 @@
-/**
- * Windsurf Transformer - XML-tagged markdown sections
- * @story 6.19 - IDE Command Auto-Sync System
- *
- * Format: Markdown with XML tags for agent sections
- * Target: .windsurf/rules/agents/*.md
- */
-
-const { getVisibleCommands, normalizeCommands } = require('../agent-parser');
-
-/**
- * Transform agent data to Windsurf format
- * @param {object} agentData - Parsed agent data from agent-parser
- * @returns {string} - Transformed content
- */
-function transform(agentData) {
-  const agent = agentData.agent || {};
-  const persona = agentData.persona_profile || {};
-
-  const icon = agent.icon || '🤖';
-  const name = agent.name || agentData.id;
-  const title = agent.title || 'AIOS Agent';
-  const whenToUse = agent.whenToUse || 'Use this agent for specific tasks';
-  const archetype = persona.archetype || '';
-
-  // Get all commands (normalized to consistent format)
-  const allCommands = normalizeCommands(agentData.commands || []);
-  const quickCommands = getVisibleCommands(allCommands, 'quick');
-
-  // Build content with XML tags
-  let content = `# ${name} Agent
-
-<agent-identity>
-${icon} **${name}** - ${title}
-ID: @${agentData.id}
-${archetype ? `Archetype: ${archetype}` : ''}
-</agent-identity>
-
-<when-to-use>
-${whenToUse}
-</when-to-use>
-
-`;
-
-  // Add commands section with XML tags
-  if (allCommands.length > 0) {
-    content += `<commands>
-`;
-    for (const cmd of allCommands) {
-      const isQuick = quickCommands.some(q => q.name === cmd.name);
-      content += `- *${cmd.name}: ${cmd.description || 'No description'}${isQuick ? ' (quick)' : ''}\n`;
-    }
-    content += `</commands>
-
-`;
-  }
-
-  // Add collaboration section if available
-  if (agentData.sections.collaboration) {
-    content += `<collaboration>
-${agentData.sections.collaboration}
-</collaboration>
-
-`;
-  }
-
-  // Add dependencies if available
-  if (agentData.dependencies) {
-    const deps = agentData.dependencies;
-    content += `<dependencies>
-`;
-    if (deps.tasks && deps.tasks.length > 0) {
-      content += `Tasks: ${deps.tasks.join(', ')}\n`;
-    }
-    if (deps.checklists && deps.checklists.length > 0) {
-      content += `Checklists: ${deps.checklists.join(', ')}\n`;
-    }
-    if (deps.tools && deps.tools.length > 0) {
-      content += `Tools: ${deps.tools.join(', ')}\n`;
-    }
-    content += `</dependencies>
-
-`;
-  }
-
-  content += `---
-*Synced from .aios-core/development/agents/${agentData.filename}*
-`;
-
-  return content;
-}
-
-/**
- * Get the target filename for this agent
- * @param {object} agentData - Parsed agent data
- * @returns {string} - Target filename
- */
-function getFilename(agentData) {
-  return agentData.filename;
-}
-
-module.exports = {
-  transform,
-  getFilename,
-  format: 'xml-tagged-markdown',
-};

package/.aios-core/product/templates/ide-rules/cline-rules.md

@@ -1,84 +0,0 @@
-# Synkra AIOS Development Rules for Cline
-
-You are working with Synkra AIOS, an AI-Orchestrated System for Full Stack Development.
-
-## Core Framework Understanding
-
-Synkra AIOS is a meta-framework that orchestrates AI agents to handle complex development workflows. Always recognize and work within this architecture.
-
-## Agent System
-
-### Agent Activation
-- Agents are activated with @agent-name syntax: @dev, @qa, @architect, @pm, @po, @sm, @analyst
-- The master agent is activated with @aios-master
-- Agent commands use the * prefix: *help, *create-story, *task, *exit
-
-### Agent Context
-When an agent is active:
-- Follow that agent's specific persona and expertise
-- Use the agent's designated workflow patterns
-- Maintain the agent's perspective throughout the interaction
-
-## Development Methodology
-
-### Story-Driven Development
-1. **Work from stories** - All development starts with a story in `docs/stories/`
-2. **Update progress** - Mark checkboxes as tasks complete: [ ] → [x]
-3. **Track changes** - Maintain the File List section in the story
-4. **Follow criteria** - Implement exactly what the acceptance criteria specify
-
-### Code Standards
-- Write clean, self-documenting code
-- Follow existing patterns in the codebase
-- Include comprehensive error handling
-- Add unit tests for all new functionality
-- Use TypeScript/JavaScript best practices
-
-### Testing Requirements
-- Run all tests before marking tasks complete
-- Ensure linting passes: `npm run lint`
-- Verify type checking: `npm run typecheck`
-- Add tests for new features
-- Test edge cases and error scenarios
-
-## AIOS Framework Structure
-
-```
-aios-core/
-├── agents/         # Agent persona definitions (YAML/Markdown)
-├── tasks/          # Executable task workflows
-├── workflows/      # Multi-step workflow definitions
-├── templates/      # Document and code templates
-├── checklists/     # Validation and review checklists
-└── rules/          # Framework rules and patterns
-
-docs/
-├── stories/        # Development stories (numbered)
-├── prd/            # Product requirement documents
-├── architecture/   # System architecture documentation
-└── guides/         # User and developer guides
-```
-
-## Cline-Specific Configuration
-
-### Agent Rules Location
-- Rules are stored in `.cline/rules/`
-- Use @agent-name to activate agents in chat
-
-### Tool Permissions
-Cline requires explicit approval for:
-- File creation/modification
-- Terminal commands
-- Browser actions
-
-### Performance Tips
-- Use the task panel for complex multi-step operations
-- Leverage diff view for reviewing changes
-- Enable auto-approve for trusted operations
-
-### MCP Integration
-- Cline supports MCP servers for extended functionality
-- Configure in Cline settings for additional tools
-
----
-*Synkra AIOS Cline Configuration v4.0.4*