gitnexus 1.6.11-rc.8 → 1.6.11

package/dist/core/ingestion/export-detection.js

@@ -227,3 +227,63 @@ export const swiftExportChecker = (node, _name) => {
 export const rubyExportChecker = (_node, _name) => true;
 /** Dart: public if no leading underscore (convention, same as Python). */
 export const dartExportChecker = (_node, name) => !name.startsWith('_');
+/** Zig declaration node types whose `pub` / `export` keyword child marks the symbol public. */
+const ZIG_DECL_TYPES = new Set(['function_declaration', 'variable_declaration']);
+/**
+ * Zig: walk to the enclosing decl, scan its direct children for an unnamed `pub`
+ * or `export` keyword token (tree-sitter-zig models both as anonymous keyword
+ * children of function_declaration / variable_declaration). Two different
+ * facts share this one flag, on purpose:
+ *   - `pub` is Zig-module visibility — reachable from another `.zig` file
+ *     through `@import`;
+ *   - `export` is C-ABI linkage (`export fn add(...)`) — the symbol lands in
+ *     the object file for FFI callers, and it never carries `pub`.
+ * `isExported` means "visible outside this compilation unit" graph-wide (C uses
+ * external linkage for the same flag), so both qualify. The `visibility`
+ * property is the Zig-only fact and is `pub`-only — see `hasZigPubKeyword`:
+ * an `export fn` without `pub` is public to C and PRIVATE to other Zig files.
+ * Container fields (struct/enum variants) are public if their enclosing
+ * variable_declaration is public.
+ *
+ * The walk stops at the FIRST declaration it reaches: a `fn` inside
+ * `pub const T = struct { … }` carries its own `pub` (or not), independent of
+ * the container's. Continuing up to the wrapper marked every private method of
+ * a public container as exported.
+ */
+export const zigExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (ZIG_DECL_TYPES.has(current.type))
+            return hasZigVisibilityKeyword(current);
+        current = current.parent;
+    }
+    return false;
+};
+/**
+ * Does this Zig declaration carry a `pub` or `export` keyword child? Feeds
+ * `isExported` (visible outside the compilation unit — to Zig importers OR to
+ * C callers).
+ */
+export function hasZigVisibilityKeyword(declNode) {
+    for (let i = 0; i < declNode.childCount; i++) {
+        const child = declNode.child(i);
+        if (child?.type === 'pub' || child?.type === 'export')
+            return true;
+    }
+    return false;
+}
+/**
+ * Does this Zig declaration carry a `pub` keyword child? Feeds `visibility`,
+ * the Zig-module fact: per the language reference, only `pub` declarations are
+ * accessible from another file via `@import`; `export` alone gives C linkage
+ * and leaves the declaration private to Zig code. So `export fn c_add` reports
+ * `isExported: true` (FFI surface) with `visibility: 'private'` (Zig surface)
+ * — two facts, two properties, deliberately not one.
+ */
+export function hasZigPubKeyword(declNode) {
+    for (let i = 0; i < declNode.childCount; i++) {
+        if (declNode.child(i)?.type === 'pub')
+            return true;
+    }
+    return false;
+}

package/dist/core/ingestion/field-extractors/configs/zig.d.ts

@@ -0,0 +1,8 @@
+import type { FieldExtractionConfig } from '../generic.js';
+/**
+ * Container fields appear as direct children of struct_declaration /
+ * enum_declaration / union_declaration — there is no separate body wrapper
+ * in this grammar, so `bodyNodeTypes` is empty and the generic factory's
+ * "iterate immediate children" pass picks them up.
+ */
+export declare const zigFieldConfig: FieldExtractionConfig;

package/dist/core/ingestion/field-extractors/configs/zig.js

@@ -0,0 +1,49 @@
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { ZIG_CONTAINER_TYPES, zigContainerName } from '../../languages/zig/captures.js';
+/**
+ * Zig containers (struct/enum/union/opaque) are anonymous in tree-sitter-zig;
+ * the binding name is the first identifier child of the parent
+ * variable_declaration, or the enclosing generic type constructor's name —
+ * `zigContainerName` is the single source.
+ */
+const extractZigOwnerName = (node, filePath) => zigContainerName(node, filePath);
+/**
+ * Container fields appear as direct children of struct_declaration /
+ * enum_declaration / union_declaration — there is no separate body wrapper
+ * in this grammar, so `bodyNodeTypes` is empty and the generic factory's
+ * "iterate immediate children" pass picks them up.
+ */
+export const zigFieldConfig = {
+    language: SupportedLanguages.Zig,
+    // `source_file`: a file-struct's top-level fields belong to the file's Struct.
+    typeDeclarationNodes: [...ZIG_CONTAINER_TYPES, 'source_file'],
+    fieldNodeTypes: ['container_field'],
+    bodyNodeTypes: [],
+    defaultVisibility: 'public',
+    extractOwnerName: extractZigOwnerName,
+    extractName(node) {
+        const name = node.childForFieldName('name');
+        // An empty container body (`struct {}`, `opaque {}`) is recovered by
+        // tree-sitter-zig 1.1.2 as one container_field with a zero-width MISSING
+        // identifier. Not a field — declining here keeps it out of the field map.
+        if (name === null || name.text.length === 0)
+            return undefined;
+        return name.text;
+    },
+    extractType(node) {
+        const typeNode = node.childForFieldName('type');
+        return typeNode?.text?.trim();
+    },
+    extractVisibility() {
+        // Zig has no per-field visibility — fields inherit the container's
+        // module-level visibility. Treat as public; the export checker decides
+        // what the *container* exposes.
+        return 'public';
+    },
+    isStatic() {
+        return false;
+    },
+    isReadonly() {
+        return false;
+    },
+};

package/dist/core/ingestion/field-extractors/generic.d.ts

@@ -20,7 +20,7 @@ export interface FieldExtractionConfig {
     /** Default visibility when no modifier is present */
     defaultVisibility: FieldVisibility;
     /** Extract owner type name from a type declaration node. */
-    extractOwnerName?: (node: SyntaxNode) => string | undefined;
+    extractOwnerName?: (node: SyntaxNode, filePath?: string) => string | undefined;
     /** Find body nodes inside a type declaration node. */
     findBodyNodes?: (node: SyntaxNode) => SyntaxNode[];
     /**

package/dist/core/ingestion/field-extractors/generic.js

@@ -21,7 +21,7 @@ export function createFieldExtractor(config) {
         extract(node, context) {
             if (!this.isTypeDeclaration(node))
                 return null;
-            const ownerFqn = config.extractOwnerName?.(node) ?? node.childForFieldName('name')?.text;
+            const ownerFqn = config.extractOwnerName?.(node, context.filePath) ?? node.childForFieldName('name')?.text;
             if (!ownerFqn)
                 return null;
             const fields = [];
@@ -62,6 +62,17 @@ export function createFieldExtractor(config) {
             if (result.length === 0 && bodyField) {
                 result.push(bodyField);
             }
+            // Grammars with no body wrapper at all: a config that declares NO
+            // `bodyNodeTypes` (tree-sitter-zig's struct_declaration holds its
+            // container_field children directly) uses the type-declaration node
+            // itself as the body. The downstream walk filters by `fieldNodeTypes`,
+            // so unrelated children are ignored. Deliberately NOT a fallback for
+            // configs that do declare body wrappers: for them a node without its
+            // wrapper is a bodiless declaration, and scanning it would change every
+            // such language for no field it could find.
+            if (result.length === 0 && bodyNodeSet.size === 0) {
+                result.push(node);
+            }
             return result;
         }
         extractFieldsFromBody(body, context, out) {

package/dist/core/ingestion/frameworks/spring/actuator-runtime.d.ts

@@ -0,0 +1,26 @@
+import type { KnowledgeGraph } from '../../../graph/types.js';
+export declare const ACTUATOR_ENDPOINTS: readonly ["mappings", "beans", "conditions", "configprops", "env"];
+type ActuatorEndpoint = (typeof ACTUATOR_ENDPOINTS)[number];
+export declare const MAX_RUNTIME_RECORDS = 50000;
+export interface SpringActuatorImportStats {
+    readonly payloads: number;
+    readonly mappings: number;
+    readonly beans: number;
+    readonly conditions: number;
+    readonly configProperties: number;
+    readonly environmentProperties: number;
+    /** Endpoint categories that exceeded the bounded import size. */
+    readonly truncatedEndpoints: readonly ActuatorEndpoint[];
+}
+export declare class SpringActuatorImportError extends Error {
+    constructor(message: string);
+}
+/**
+ * Import explicitly supplied Spring Boot Actuator snapshots. Runtime evidence
+ * is additive: it confirms existing static nodes where possible and creates
+ * conservative synthetic Route/Bean/Property nodes otherwise. Raw payloads,
+ * condition messages, config values, env values, origins, and source names are
+ * never copied into graph properties or logs.
+ */
+export declare function importSpringActuatorRuntime(graph: KnowledgeGraph, repoPath: string, configuredPath: string): Promise<SpringActuatorImportStats>;
+export {};