feat: Epic NOGIC Code Intelligence + Installation Health + Token Optimization

.aios-core/core/code-intel/code-intel-client.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { CodeGraphProvider } = require('./providers/code-graph-provider');
+const { RegistryProvider } = require('./providers/registry-provider');
 
 // --- Constants (adjustable, not hardcoded magic numbers) ---
 const CIRCUIT_BREAKER_THRESHOLD = 3;
@@ -51,10 +52,19 @@ class CodeIntelClient {
 
   /**
    * Register default providers based on configuration.
+   * Provider priority: RegistryProvider FIRST (native, T1), then CodeGraphProvider (MCP, T3).
+   * First provider with isAvailable() === true wins.
    * @private
    */
   _registerDefaultProviders(options) {
-    // Code Graph MCP is the primary (and currently only) provider
+    // RegistryProvider — native, T1, always available when registry exists
+    const registryProvider = new RegistryProvider({
+      registryPath: options.registryPath || null,
+      projectRoot: options.projectRoot || null,
+    });
+    this._providers.push(registryProvider);
+
+    // Code Graph MCP — T3, available when mcpCallFn is configured
     const codeGraphProvider = new CodeGraphProvider({
       mcpServerName: options.mcpServerName || 'code-graph',
       mcpCallFn: options.mcpCallFn || null,
@@ -74,17 +84,21 @@ class CodeIntelClient {
 
   /**
    * Detect and return the first available provider.
+   * Uses polymorphic isAvailable() — first provider that returns true wins.
    * @returns {import('./providers/provider-interface').CodeIntelProvider|null}
    * @private
    */
   _detectProvider() {
     if (this._activeProvider) return this._activeProvider;
 
     for (const provider of this._providers) {
-      // A provider is considered "available" if it has a configured mcpCallFn
-      if (provider.options && typeof provider.options.mcpCallFn === 'function') {
-        this._activeProvider = provider;
-        return provider;
+      try {
+        if (typeof provider.isAvailable === 'function' && provider.isAvailable()) {
+          this._activeProvider = provider;
+          return provider;
+        }
+      } catch (_err) {
+        // Provider threw during availability check — treat as unavailable
       }
     }
 

.aios-core/core/code-intel/hook-runtime.js

@@ -0,0 +1,186 @@
+'use strict';
+
+const path = require('path');
+const { RegistryProvider } = require('./providers/registry-provider');
+
+/** Cached provider instance (survives across hook invocations in same process). */
+let _provider = null;
+let _providerRoot = null;
+
+/**
+ * Get or create a RegistryProvider singleton.
+ * Resets if projectRoot changes between calls.
+ * @param {string} projectRoot - Project root directory
+ * @returns {RegistryProvider}
+ */
+function getProvider(projectRoot) {
+  if (!_provider || _providerRoot !== projectRoot) {
+    _provider = new RegistryProvider({ projectRoot });
+    _providerRoot = projectRoot;
+  }
+  return _provider;
+}
+
+/**
+ * Resolve code intelligence context for a file being written/edited.
+ *
+ * Queries RegistryProvider for:
+ * - Entity definition (path, layer, purpose, type)
+ * - References (files that use this entity)
+ * - Dependencies (entities this file depends on)
+ *
+ * @param {string} filePath - Absolute or relative path to the target file
+ * @param {string} cwd - Project root / working directory
+ * @returns {{ entity: Object|null, references: Array|null, dependencies: Object|null }|null}
+ */
+async function resolveCodeIntel(filePath, cwd) {
+  if (!filePath || !cwd) return null;
+
+  try {
+    const provider = getProvider(cwd);
+    if (!provider.isAvailable()) return null;
+
+    // Normalize to relative path (registry uses relative paths)
+    let relativePath = filePath;
+    if (path.isAbsolute(filePath)) {
+      relativePath = path.relative(cwd, filePath).replace(/\\/g, '/');
+    } else {
+      relativePath = filePath.replace(/\\/g, '/');
+    }
+
+    // Run all three queries in parallel
+    const [definition, references, dependencies] = await Promise.all([
+      provider.findDefinition(relativePath),
+      provider.findReferences(relativePath),
+      provider.analyzeDependencies(relativePath),
+    ]);
+
+    // Treat empty dependency graph as no data
+    const hasUsefulDeps = dependencies && dependencies.nodes && dependencies.nodes.length > 0;
+
+    // If nothing found at all, try searching by the file basename
+    if (!definition && !references && !hasUsefulDeps) {
+      const basename = path.basename(relativePath, path.extname(relativePath));
+      const fallbackDef = await provider.findDefinition(basename);
+      if (!fallbackDef) return null;
+
+      const [fallbackRefs, fallbackDeps] = await Promise.all([
+        provider.findReferences(basename),
+        provider.analyzeDependencies(basename),
+      ]);
+
+      return {
+        entity: fallbackDef,
+        references: fallbackRefs,
+        dependencies: fallbackDeps,
+      };
+    }
+
+    return {
+      entity: definition,
+      references,
+      dependencies,
+    };
+  } catch (_err) {
+    // Guard against provider exceptions to avoid unhandled rejections in hook runtime
+    return null;
+  }
+}
+
+/**
+ * Format code intelligence data as XML for injection into Claude context.
+ *
+ * @param {Object|null} intel - Result from resolveCodeIntel()
+ * @param {string} filePath - Target file path (for display)
+ * @returns {string|null} XML string or null if no data
+ */
+function formatAsXml(intel, filePath) {
+  if (!intel) return null;
+
+  const { entity, references, dependencies } = intel;
+
+  // At least one piece of data must exist
+  if (!entity && !references && !dependencies) return null;
+
+  const lines = ['<code-intel-context>'];
+  lines.push(`  <target-file>${escapeXml(filePath)}</target-file>`);
+
+  // Entity definition
+  if (entity) {
+    lines.push('  <existing-entity>');
+    if (entity.file) lines.push(`    <path>${escapeXml(entity.file)}</path>`);
+    if (entity.context) lines.push(`    <purpose>${escapeXml(entity.context)}</purpose>`);
+    lines.push('  </existing-entity>');
+  }
+
+  // References
+  if (references && references.length > 0) {
+    // Deduplicate by file path
+    const uniqueRefs = [];
+    const seen = new Set();
+    for (const ref of references) {
+      if (ref.file && !seen.has(ref.file)) {
+        seen.add(ref.file);
+        uniqueRefs.push(ref);
+      }
+    }
+
+    lines.push(`  <referenced-by count="${uniqueRefs.length}">`);
+    for (const ref of uniqueRefs.slice(0, 15)) {
+      const ctx = ref.context ? ` context="${escapeXml(ref.context)}"` : '';
+      lines.push(`    <ref file="${escapeXml(ref.file)}"${ctx} />`);
+    }
+    if (uniqueRefs.length > 15) {
+      lines.push(`    <!-- ...and ${uniqueRefs.length - 15} more -->`);
+    }
+    lines.push('  </referenced-by>');
+  }
+
+  // Dependencies
+  if (dependencies && dependencies.nodes && dependencies.nodes.length > 1) {
+    // First node is the target itself, rest are dependencies
+    const depNodes = dependencies.nodes.slice(1);
+    lines.push(`  <dependencies count="${depNodes.length}">`);
+    for (const dep of depNodes.slice(0, 10)) {
+      const layer = dep.layer ? ` layer="${dep.layer}"` : '';
+      lines.push(`    <dep name="${escapeXml(dep.name)}"${layer} />`);
+    }
+    if (depNodes.length > 10) {
+      lines.push(`    <!-- ...and ${depNodes.length - 10} more -->`);
+    }
+    lines.push('  </dependencies>');
+  }
+
+  lines.push('</code-intel-context>');
+  return lines.join('\n');
+}
+
+/**
+ * Escape special XML characters.
+ * @param {string} str
+ * @returns {string}
+ */
+function escapeXml(str) {
+  if (!str) return '';
+  return String(str)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+/**
+ * Reset cached provider (for testing).
+ */
+function _resetForTesting() {
+  _provider = null;
+  _providerRoot = null;
+}
+
+module.exports = {
+  resolveCodeIntel,
+  formatAsXml,
+  escapeXml,
+  getProvider,
+  _resetForTesting,
+};

.aios-core/core/code-intel/index.js

@@ -4,6 +4,7 @@ const { CodeIntelClient } = require('./code-intel-client');
 const { CodeIntelEnricher } = require('./code-intel-enricher');
 const { CodeIntelProvider, CAPABILITIES } = require('./providers/provider-interface');
 const { CodeGraphProvider, TOOL_MAP } = require('./providers/code-graph-provider');
+const { RegistryProvider } = require('./providers/registry-provider');
 
 // Singleton client instance (lazily initialized)
 let _defaultClient = null;
@@ -127,6 +128,7 @@ module.exports = {
   CodeIntelEnricher,
   CodeIntelProvider,
   CodeGraphProvider,
+  RegistryProvider,
 
   // Constants
   CAPABILITIES,

.aios-core/core/code-intel/providers/code-graph-provider.js

@@ -29,6 +29,14 @@ class CodeGraphProvider extends CodeIntelProvider {
     this._mcpServerName = options.mcpServerName || 'code-graph';
   }
 
+  /**
+   * Code Graph provider is available when mcpCallFn is configured.
+   * @returns {boolean}
+   */
+  isAvailable() {
+    return typeof this.options.mcpCallFn === 'function';
+  }
+
   /**
    * Execute an MCP tool call via the configured server.
    * This method is the single point of MCP communication — all capabilities route through here.

.aios-core/core/code-intel/providers/provider-interface.js

@@ -14,6 +14,15 @@ class CodeIntelProvider {
     this.options = options;
   }
 
+  /**
+   * Check if this provider is available and can serve requests.
+   * Subclasses MUST override this to indicate availability.
+   * @returns {boolean}
+   */
+  isAvailable() {
+    return false;
+  }
+
   /**
    * Locate the definition of a symbol.
    * @param {string} symbol - Symbol name to find