ai-developer-skill-os 8.1.9 → 8.2.0

package/bin/install.js

@@ -71,7 +71,7 @@ function runInstall(ideChoice, scopeChoice) {
   if (isGlobal) {
     const homeDir = os.homedir();
     if (ide === 'antigravity') {
-      targetDir = path.join(homeDir, '.gemini', 'config', '.agents');
+      targetDir = path.join(homeDir, '.gemini', 'config');
     } else {
       targetDir = path.join(homeDir, '.ai-developer-skill-os', '.agents');
     }
@@ -87,6 +87,44 @@ function runInstall(ideChoice, scopeChoice) {
     if (fs.existsSync(sourceDir)) {
       copyRecursiveSync(sourceDir, targetDir);
       console.log(`✅ Đã copy toàn bộ kiến trúc .agents vào: ${targetDir}`);
+      
+      if (isGlobal && ide === 'antigravity') {
+        const targetDirPosix = targetDir.replace(/\\/g, '/');
+        
+        function walkAndReplace(dir) {
+          const files = fs.readdirSync(dir);
+          for (const file of files) {
+            const fullPath = path.join(dir, file);
+            if (fs.statSync(fullPath).isDirectory()) {
+              walkAndReplace(fullPath);
+            } else if (fullPath.endsWith('.md') || fullPath.endsWith('.yml') || fullPath.endsWith('.yaml') || fullPath.endsWith('.json')) {
+              let content = fs.readFileSync(fullPath, 'utf8');
+              let modified = false;
+              
+              const dirsToRewrite = ['skills', 'registry', 'rules', 'workflows', 'knowledge', 'examples', 'docs'];
+              for (const d of dirsToRewrite) {
+                const regex = new RegExp(`\\.agents/${d}`, 'g');
+                if (regex.test(content)) {
+                  content = content.replace(regex, `${targetDirPosix}/${d}`);
+                  modified = true;
+                }
+              }
+              
+              if (content.includes('.agents/skills.json')) {
+                content = content.replace(/\.agents\/skills\.json/g, `${targetDirPosix}/skills.json`);
+                modified = true;
+              }
+      
+              if (modified) {
+                fs.writeFileSync(fullPath, content, 'utf8');
+              }
+            }
+          }
+        }
+        
+        walkAndReplace(targetDir);
+        console.log(`✅ Đã cập nhật đường dẫn tuyệt đối cho cấu hình Global Antigravity`);
+      }
     } else {
       console.error(`❌ Lỗi: Không tìm thấy thư mục nguồn ${sourceDir}`);
       return;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ai-developer-skill-os",
-  "version": "8.1.9",
-  "description": "Agent Engineering OS: A deterministic capability graph, governance rules, and dynamic knowledge base for AI coding agents.",
+  "version": "8.2.0",
+  "description": "EDAOS v8.2 — Governed Capability Metadata & Eval Platform: Blueprints organize, manifests govern, registries accelerate.",
   "main": "bin/install.js",
   "files": [
     "bin",
@@ -20,9 +20,10 @@
     "node": ">=18.0.0"
   },
   "scripts": {
+    "build:registry": "node tooling/build-registry.js",
     "test": "vitest run",
     "test:watch": "vitest",
-    "test:registry": "vitest run --config vitest.config.js",
+    "test:registry": "vitest run && node tooling/build-registry.js",
     "test:graph": "node tooling/validate-graph.js",
     "lint": "node bin/lint.js",
     "test:agent": "node tests/agent-evaluation/runner/evaluate-routing.js",
@@ -49,7 +50,11 @@
     "developer",
     "agent",
     "prompts",
-    "framework"
+    "framework",
+    "edaos",
+    "manifest",
+    "registry",
+    "eval"
   ],
   "author": "Quang Khánh",
   "license": "MIT",

package/tooling/build-registry.js

@@ -0,0 +1,186 @@
+/**
+ * build-registry.js
+ * V8.2 Governed Capability Metadata & Eval Platform
+ * Generates registry/index.yaml (lightweight lookup) and registry/graph.json (O(1) graph & cycle check)
+ * 
+ * Usage: node tooling/build-registry.js
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import yaml from 'js-yaml';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const SKILLS_DIR = path.join(__dirname, '../.agents/skills');
+const REGISTRY_DIR = path.join(__dirname, '../.agents/registry');
+const INDEX_YAML = path.join(REGISTRY_DIR, 'index.yaml');
+const GRAPH_JSON = path.join(REGISTRY_DIR, 'graph.json');
+
+function parseYamlFile(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (match) {
+      return yaml.load(match[1]);
+    }
+    return yaml.load(content);
+  } catch (e) {
+    console.error(`[WARN] Failed to parse YAML from ${filePath}: ${e.message}`);
+    return null;
+  }
+}
+
+function buildRegistry() {
+  console.log('🔄 Building V8.2 Governed Capability Registry & O(1) Runtime Graph...');
+
+  if (!fs.existsSync(SKILLS_DIR)) {
+    console.error('❌ Skills directory not found:', SKILLS_DIR);
+    process.exit(1);
+  }
+
+  fs.mkdirSync(REGISTRY_DIR, { recursive: true });
+
+  const dirs = fs.readdirSync(SKILLS_DIR).filter(d => 
+    !d.startsWith('_') && fs.statSync(path.join(SKILLS_DIR, d)).isDirectory()
+  );
+
+  const capabilities = {};
+  const adjacency = {};
+  const reverseAdjacency = {};
+
+  for (const dir of dirs) {
+    const capYamlPath = path.join(SKILLS_DIR, dir, 'capability.yaml');
+    const skillMdPath = path.join(SKILLS_DIR, dir, 'SKILL.md');
+    
+    let meta = null;
+    let fromCapabilityYaml = false;
+
+    if (fs.existsSync(capYamlPath)) {
+      meta = parseYamlFile(capYamlPath);
+      fromCapabilityYaml = true;
+    } else if (fs.existsSync(skillMdPath)) {
+      meta = parseYamlFile(skillMdPath);
+    }
+
+    if (!meta) continue;
+
+    const id = meta.id || meta.name || dir;
+    const version = meta.version || '8.2.0';
+    const description = meta.description || '';
+    
+    // Normalize tags
+    let tags = meta.tags || meta.keywords || [];
+    if (!Array.isArray(tags) || tags.length === 0) {
+      // Derive simple tags from dir words
+      tags = dir.replace(/^qk-/, '').split('-');
+    }
+
+    // Normalize dependencies
+    let dependencies = meta.dependencies || [];
+    if (!fromCapabilityYaml) {
+      // Derive from V8.1 skill frontmatter decision_boundary / workflow
+      const deps = new Set();
+      if (meta.workflow && typeof meta.workflow === 'string') deps.add(meta.workflow);
+      if (meta.decision_boundary?.delegates_to) {
+        meta.decision_boundary.delegates_to.forEach(d => deps.add(d));
+      }
+      dependencies = Array.from(deps);
+    }
+
+    capabilities[id] = {
+      path: `.agents/skills/${dir}`,
+      version,
+      tags,
+      dependencies
+    };
+
+    adjacency[id] = dependencies;
+    if (!reverseAdjacency[id]) reverseAdjacency[id] = [];
+  }
+
+  // Populate reverse adjacency for orphan detection
+  for (const [id, deps] of Object.entries(adjacency)) {
+    for (const dep of deps) {
+      if (!reverseAdjacency[dep]) reverseAdjacency[dep] = [];
+      reverseAdjacency[dep].push(id);
+    }
+  }
+
+  // Detect cycles using DFS
+  let hasCycles = false;
+  const visited = {};
+  const recursionStack = {};
+
+  function detectCycle(node) {
+    visited[node] = true;
+    recursionStack[node] = true;
+
+    const deps = adjacency[node] || [];
+    for (const dep of deps) {
+      if (!visited[dep]) {
+        if (detectCycle(dep)) return true;
+      } else if (recursionStack[dep]) {
+        return true;
+      }
+    }
+
+    recursionStack[node] = false;
+    return false;
+  }
+
+  for (const node of Object.keys(adjacency)) {
+    if (!visited[node]) {
+      if (detectCycle(node)) {
+        hasCycles = true;
+        break;
+      }
+    }
+  }
+
+  // Build Graph JSON (O(1) Runtime lookups)
+  const graphNodes = {};
+  for (const [id, data] of Object.entries(capabilities)) {
+    const dependents = reverseAdjacency[id] || [];
+    const isOrphan = data.dependencies.length === 0 && dependents.length === 0 && id !== 'qk-orchestrator' && id !== 'qk-help';
+
+    graphNodes[id] = {
+      path: data.path,
+      version: data.version,
+      tags: data.tags,
+      dependencies: data.dependencies,
+      dependents,
+      is_orphan: isOrphan
+    };
+  }
+
+  const graphJsonData = {
+    schema_version: 1,
+    manifest_version: '8.2',
+    generated_at: new Date().toISOString(),
+    nodes: graphNodes,
+    adjacency,
+    stats: {
+      total_capabilities: Object.keys(capabilities).length,
+      has_cycles: hasCycles
+    }
+  };
+
+  // Build Registry Index YAML (Lightweight lookup)
+  const indexYamlContent = `# AUTO-GENERATED BY registry-builder (tooling/build-registry.js)\n# DO NOT EDIT MANUALLY. THIS IS A GENERATED RUNTIME ARTIFACT.\n` +
+    yaml.dump({
+      schema_version: 1,
+      manifest_version: '8.2',
+      generated_at: new Date().toISOString(),
+      capabilities
+    }, { indent: 2 });
+
+  fs.writeFileSync(INDEX_YAML, indexYamlContent, 'utf8');
+  fs.writeFileSync(GRAPH_JSON, JSON.stringify(graphJsonData, null, 2), 'utf8');
+
+  console.log(`✅ Generated lightweight registry index at .agents/registry/index.yaml (${Object.keys(capabilities).length} capabilities)`);
+  console.log(`✅ Generated O(1) adjacency graph at .agents/registry/graph.json (has_cycles: ${hasCycles})`);
+}
+
+buildRegistry();