gitnexus 1.6.10-aptos.0 → 1.6.10-aptos.1

package/README.md

@@ -375,6 +375,31 @@ described in [Move compiler provisioning](#move-compiler-provisioning) —
 including the `MOVE_FLOW` override and `GITNEXUS_SKIP_MOVE_FLOW=1` for
 air-gapped hosts.
 
+### Analyzing real-world Move repositories
+
+Real repos routinely contain Move packages that cannot build standalone (test
+fixtures, examples, fuzzer corpora — `aptos-core` alone has 470+). `analyze`
+handles them per package instead of giving up:
+
+- **Unbuildable packages are skipped with a warning**, not fatal: their
+  `.move` files stay out of the graph and the final summary names each skipped
+  package with the compiler's first diagnostic. Set `GITNEXUS_MOVE_STRICT=1`
+  to make any build failure abort the analyze instead.
+- **`_` placeholder addresses** (`econia = "_"` in `[addresses]`) are caught
+  pre-flight — MoveFlow has no dev-mode build, so set concrete addresses in
+  `Move.toml` or exclude the package.
+- **Builds with compiler errors still yield facts, at reduced fidelity**: the
+  MoveFlow compiler silently omits inferred `acquires` data from erroring
+  builds, so such packages are ingested with a persistent
+  "compiled with errors" warning. A common cause is a framework dependency
+  newer than MoveFlow's pinned compiler (e.g. unrecognized spec pragmas).
+- **`.gitnexusignore`** (gitignore syntax, repo root) excludes directories from
+  analysis entirely — the fastest way to scope large repos to the packages you
+  care about, and the remedy the skip warnings suggest.
+- **Cold builds of git-based framework dependencies can exceed the 5-minute
+  compile budget**; raise it with `GITNEXUS_MOVE_FLOW_TIMEOUT_MS` (e.g.
+  `1800000` for 30 min) for the first analyze.
+
 ## Release candidates
 
 Stable releases publish to the default `latest` dist-tag. When a pull request

package/dist/cli/analyze.js

@@ -1193,6 +1193,14 @@ const analyzeCommandImpl = async (inputPath, cliOptions, runnerIdentityAtBootstr
                 `  Install it once with network access (GITNEXUS_LBUG_EXTENSION_INSTALL=auto) then rerun, or\n` +
                 `  run \`gitnexus analyze --repair-fts\` when connected. Run \`gitnexus doctor\` for details.`);
         }
+        // Standalone-ingest warnings (skipped/degraded Move packages) share the
+        // FTS warning's rationale: mid-run progress lines scroll away, so anything
+        // the operator must act on has to reappear in the final summary.
+        if (result.ingestWarnings && result.ingestWarnings.length > 0) {
+            for (const warning of result.ingestWarnings) {
+                console.log(`\n  Warning: ${warning}`);
+            }
+        }
         try {
             await fs.access(getGlobalRegistryPath());
         }

package/dist/core/ingestion/pipeline-phases/standalone-ingest.d.ts

@@ -5,6 +5,12 @@ import type { PipelinePhase } from './types.js';
  */
 export interface StandaloneIngestOutput {
     readonly ingestedFiles: ReadonlySet<string>;
+    /**
+     * Operator-actionable warnings the ingester wants surfaced in the persistent
+     * CLI summary (e.g. a package it had to skip or ingest at degraded fidelity).
+     * Language-neutral: the pipeline passes these through without interpreting.
+     */
+    readonly ingestWarnings?: readonly string[];
 }
 /** Default no-op used when the caller does not supply a standalone ingester. */
 export declare const emptyStandaloneIngestPhase: PipelinePhase<StandaloneIngestOutput>;

package/dist/core/ingestion/pipeline.js

@@ -81,6 +81,14 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
     const { totalFiles, usedWorkerPool } = getPhaseOutput(results, 'parse');
     let communityResult;
     let processResult;
+    // Standalone-ingest warnings, passed through opaquely (language-neutral).
+    let ingestWarnings;
+    try {
+        ingestWarnings = getPhaseOutput(results, 'standaloneIngest').ingestWarnings;
+    }
+    catch {
+        /* phase filtered out of this run — nothing to surface */
+    }
     const scopeResolutionOutput = getPhaseOutput(results, 'scopeResolution');
     const resolutionOutcomes = scopeResolutionOutput.resolutionOutcomes;
     // Streamed PDG-emit manifest (#2202): present only when streaming was on.
@@ -110,5 +118,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         resolutionOutcomes,
         usedWorkerPool,
         pdgEmitManifest,
+        ingestWarnings,
     };
 };

package/dist/core/move/consistency.d.ts

@@ -6,7 +6,15 @@ export interface MoveConsistencyIssue {
     code: 'missing-owned-caller' | 'missing-owned-callee' | 'malformed-source-evidence' | 'unresolved-resource-target'
     /** Package with .move sources returned facts `{}` - severity policy in
      *  `emptyFactsIssue` below. */
-     | 'empty-package-facts';
+     | 'empty-package-facts'
+    /** Package skipped: move-flow could not build it (skip-and-warn, #2624). */
+     | 'package-build-failed'
+    /** Package skipped pre-flight: Move.toml [addresses] has `_` placeholders
+     *  move-flow cannot resolve (it has no dev-mode build). */
+     | 'unresolved-named-address'
+    /** Package ingested, but its build carries compiler errors - move-flow
+     *  silently omits inferred facts (acquires) from such builds. */
+     | 'degraded-package-facts';
     severity: MoveConsistencySeverity;
     message: string;
     details?: Record<string, unknown>;
@@ -25,4 +33,42 @@ export interface EmptyFactsPackage {
  * error. Pure mapping - probing the status (client I/O) stays in the phase.
  */
 export declare function emptyFactsIssue(pkg: EmptyFactsPackage): MoveConsistencyIssue;
+/**
+ * A package skipped because move-flow could not build it (skip-and-warn).
+ * Warning, not error: the analyze continues and the skip is surfaced in the
+ * CLI summary; GITNEXUS_MOVE_STRICT=1 restores the historical fatal behavior.
+ */
+export declare function buildFailedIssue(pkg: {
+    pkgRoot: string;
+    moveFileCount: number;
+    diagnostics: string;
+}): MoveConsistencyIssue;
+/**
+ * A package skipped pre-flight: its Move.toml `[addresses]` contains `_`
+ * placeholders. move-flow's `move_package_query` has no dev-mode, so the build
+ * would always fail with "Unresolved addresses" - skip with the remedy instead.
+ */
+export declare function unresolvedAddressIssue(pkg: {
+    pkgRoot: string;
+    moveFileCount: number;
+    placeholders: string[];
+}): MoveConsistencyIssue;
+/**
+ * A package that WAS ingested but whose build carries compiler errors.
+ * move-flow still serves structurally complete facts for such builds but
+ * silently drops inference-stage output (`acquiresInferred`), so the graph is
+ * missing ACQUIRES edges/properties — surface it instead of implying full
+ * fidelity. (Commonly: a framework dependency newer than move-flow's pinned
+ * compiler, e.g. spec pragmas it does not recognize.)
+ */
+export declare function degradedFactsIssue(pkg: {
+    pkgRoot: string;
+    diagnostics: string;
+}): MoveConsistencyIssue;
+/**
+ * The persistent CLI-summary warnings for a run's Move issues: the three
+ * skip/degrade codes are operator-actionable and must survive past the
+ * scrolling progress bar (same rationale as the FTS warning, #1161).
+ */
+export declare function cliWarningsFromIssues(issues: readonly MoveConsistencyIssue[]): string[];
 export declare function validateMoveIngestOutput(graph: KnowledgeGraph, moveIngest: MoveIngestOutput): MoveConsistencyIssue[];

package/dist/core/move/consistency.js

@@ -35,6 +35,90 @@ export function emptyFactsIssue(pkg) {
         details: { packageRoot: pkgRoot, moveFileCount, diagnostics: status.diagnostics },
     };
 }
+/** First non-empty line of a compiler diagnostic blob (for one-line summaries). */
+function firstDiagnosticLine(diagnostics) {
+    if (!diagnostics)
+        return '';
+    for (const line of diagnostics.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    return '';
+}
+/**
+ * A package skipped because move-flow could not build it (skip-and-warn).
+ * Warning, not error: the analyze continues and the skip is surfaced in the
+ * CLI summary; GITNEXUS_MOVE_STRICT=1 restores the historical fatal behavior.
+ */
+export function buildFailedIssue(pkg) {
+    const firstLine = firstDiagnosticLine(pkg.diagnostics);
+    return {
+        code: 'package-build-failed',
+        severity: 'warning',
+        message: `Move package skipped — move-flow could not build it` +
+            (firstLine ? ` (${firstLine})` : '') +
+            `: ${pkg.pkgRoot}. Fix the package or exclude its directory via .gitnexusignore; ` +
+            `set GITNEXUS_MOVE_STRICT=1 to make build failures fatal.`,
+        details: {
+            packageRoot: pkg.pkgRoot,
+            moveFileCount: pkg.moveFileCount,
+            diagnostics: pkg.diagnostics,
+        },
+    };
+}
+/**
+ * A package skipped pre-flight: its Move.toml `[addresses]` contains `_`
+ * placeholders. move-flow's `move_package_query` has no dev-mode, so the build
+ * would always fail with "Unresolved addresses" - skip with the remedy instead.
+ */
+export function unresolvedAddressIssue(pkg) {
+    return {
+        code: 'unresolved-named-address',
+        severity: 'warning',
+        message: `Move package skipped — named address(es) ${pkg.placeholders.join(', ')} are "_" ` +
+            `placeholders in Move.toml (move-flow cannot build dev-mode): ${pkg.pkgRoot}. ` +
+            `Set concrete addresses in [addresses] or exclude the directory via .gitnexusignore.`,
+        details: {
+            packageRoot: pkg.pkgRoot,
+            moveFileCount: pkg.moveFileCount,
+            placeholders: pkg.placeholders,
+        },
+    };
+}
+/**
+ * A package that WAS ingested but whose build carries compiler errors.
+ * move-flow still serves structurally complete facts for such builds but
+ * silently drops inference-stage output (`acquiresInferred`), so the graph is
+ * missing ACQUIRES edges/properties — surface it instead of implying full
+ * fidelity. (Commonly: a framework dependency newer than move-flow's pinned
+ * compiler, e.g. spec pragmas it does not recognize.)
+ */
+export function degradedFactsIssue(pkg) {
+    const firstLine = firstDiagnosticLine(pkg.diagnostics);
+    return {
+        code: 'degraded-package-facts',
+        severity: 'warning',
+        message: `Move package compiled with errors — compiler-inferred facts (acquires) may be ` +
+            `incomplete` +
+            (firstLine ? ` (${firstLine})` : '') +
+            `: ${pkg.pkgRoot}`,
+        details: { packageRoot: pkg.pkgRoot, diagnostics: pkg.diagnostics },
+    };
+}
+/**
+ * The persistent CLI-summary warnings for a run's Move issues: the three
+ * skip/degrade codes are operator-actionable and must survive past the
+ * scrolling progress bar (same rationale as the FTS warning, #1161).
+ */
+export function cliWarningsFromIssues(issues) {
+    const surfaced = [
+        'package-build-failed',
+        'unresolved-named-address',
+        'degraded-package-facts',
+    ];
+    return issues.filter((i) => surfaced.includes(i.code)).map((i) => i.message);
+}
 export function validateMoveIngestOutput(graph, moveIngest) {
     const issues = [];
     for (const [moduleQualified, filePath] of moveIngest.moduleFileMap) {

package/dist/core/move/move-ingest.d.ts

@@ -45,5 +45,8 @@ export interface MoveIngestOutput extends StandaloneIngestOutput {
     }[];
     /** Non-fatal consistency issues found after Move ingestion. */
     consistencyIssues: MoveConsistencyIssue[];
+    /** Operator-actionable warnings for the persistent CLI summary (skipped or
+     *  degraded packages). Part of the neutral StandaloneIngestOutput contract. */
+    ingestWarnings?: readonly string[];
 }
 export declare function createMoveIngestPhase(client: MoveFlowClient | null): PipelinePhase<MoveIngestOutput>;

package/dist/core/move/move-ingest.js

@@ -19,12 +19,13 @@
  *          ACQUIRES/USES_TYPE/ENTRY_POINT_OF/IMPORTS edges)
  */
 import * as path from 'node:path';
+import { readFile } from 'node:fs/promises';
 import { getPhaseOutput } from '../ingestion/pipeline-phases/types.js';
 import { MOVE_EDGE_REASON, moveRepoRelativePath } from './constants.js';
 import { MoveFlowToolCallError, } from './mcp-client.js';
 import { buildLocalNameIndex, mapFactsToGraph, resolveFriendEdges, resolveLambdaHostEdges, resolveResourceEdges, resolveTypeRefEdges, } from './facts-mapper.js';
 import { moveModuleNodeId, moveModuleQualifiedName, moveRelId } from './symbol-id.js';
-import { emptyFactsIssue, validateMoveIngestOutput, } from './consistency.js';
+import { buildFailedIssue, cliWarningsFromIssues, degradedFactsIssue, emptyFactsIssue, unresolvedAddressIssue, validateMoveIngestOutput, } from './consistency.js';
 import { createMoveEntryPointEdges } from './entry-points.js';
 function createState() {
     return {
@@ -54,8 +55,49 @@ function toOutput(state, packageRoots, consistencyIssues = []) {
         callGraphByPackage: state.callGraphByPackage,
         droppedResourceRefs: state.droppedResourceRefs,
         consistencyIssues,
+        ingestWarnings: cliWarningsFromIssues(consistencyIssues),
     };
 }
+/** GITNEXUS_MOVE_STRICT=1|true restores the historical fatal-on-build-failure
+ *  behavior instead of skip-and-warn. */
+function isStrictMove() {
+    const v = process.env.GITNEXUS_MOVE_STRICT?.trim().toLowerCase();
+    return v === '1' || v === 'true';
+}
+/**
+ * Named addresses assigned the `_` placeholder in a package's Move.toml
+ * `[addresses]` section. Deliberately a line-oriented scan, not a TOML parser:
+ * the two token shapes involved (`[section]`, `name = "_"`) are stable across
+ * every Move manifest and a full parser dependency buys nothing here.
+ * Unreadable/absent manifest → `[]` (the build itself will surface that).
+ */
+async function findPlaceholderAddresses(pkgRoot) {
+    let text;
+    try {
+        text = await readFile(path.join(pkgRoot, 'Move.toml'), 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const placeholders = [];
+    let section = '';
+    for (const raw of text.split('\n')) {
+        const line = raw.replace(/#.*$/, '').trim();
+        if (!line)
+            continue;
+        const sectionMatch = line.match(/^\[(.+)\]$/);
+        if (sectionMatch) {
+            section = sectionMatch[1].trim();
+            continue;
+        }
+        if (section !== 'addresses')
+            continue;
+        const kv = line.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=\s*["']_["']$/);
+        if (kv)
+            placeholders.push(kv[1]);
+    }
+    return placeholders;
+}
 /** Add a mapped package's nodes/edges to the graph and merge its identity maps. */
 function applyMapped(graph, mapped, pkgRoot, state) {
     for (const node of mapped.nodes)
@@ -121,6 +163,8 @@ export function createMoveIngestPhase(client) {
                 moveFilesByPackage.set(owner, files);
             }
             const emptyFactsPackages = [];
+            const packageIssues = [];
+            const strictMove = isStrictMove();
             // Pass 1: per-package nodes/edges (all packages first, so cross-package
             // CALLS in Pass 2 can resolve callees in later packages).
             for (const pkgRoot of packageRoots) {
@@ -130,6 +174,14 @@ export function createMoveIngestPhase(client) {
                     message: `Ingesting Move package: ${path.basename(pkgRoot)}`,
                     stats: { filesProcessed: 0, totalFiles, nodesCreated: ctx.graph.nodeCount },
                 });
+                const pkgMoveFiles = moveFilesByPackage.get(pkgRoot) ?? [];
+                // Pre-flight: `_` placeholder addresses always fail the build (move-flow
+                // has no dev-mode), so skip before spending a compile on the known outcome.
+                const placeholders = await findPlaceholderAddresses(pkgRoot);
+                if (placeholders.length > 0) {
+                    packageIssues.push(unresolvedAddressIssue({ pkgRoot, moveFileCount: pkgMoveFiles.length, placeholders }));
+                    continue;
+                }
                 let callGraphData;
                 let factsMap;
                 try {
@@ -138,14 +190,30 @@ export function createMoveIngestPhase(client) {
                 }
                 catch (err) {
                     if (err instanceof MoveFlowToolCallError) {
-                        // userActionable: rendered as a one-liner without a stack - a Move
-                        // package that does not build (bad manifest, missing dependency,
-                        // nonexistent path) is an operator problem, not a code bug.
-                        throw Object.assign(new Error(`move-flow could not build Move package ${pkgRoot}: ${err.message}`), { userActionable: true });
+                        // A Move package that does not build (bad manifest, missing
+                        // dependency, unresolved address) is an operator problem, not a
+                        // code bug. Default: skip the package (its files stay un-ingested,
+                        // like the empty-facts path) and surface a persistent warning —
+                        // one broken auxiliary package must not abort the whole analyze.
+                        if (strictMove) {
+                            // userActionable: rendered as a one-liner without a stack.
+                            throw Object.assign(new Error(`move-flow could not build Move package ${pkgRoot}: ${err.message}`), { userActionable: true });
+                        }
+                        packageIssues.push(buildFailedIssue({
+                            pkgRoot,
+                            moveFileCount: pkgMoveFiles.length,
+                            diagnostics: err.message,
+                        }));
+                        ctx.onProgress({
+                            phase: 'moveIngest',
+                            percent: 18,
+                            message: `Skipping Move package (build failed): ${path.basename(pkgRoot)}`,
+                            stats: { filesProcessed: 0, totalFiles, nodesCreated: ctx.graph.nodeCount },
+                        });
+                        continue;
                     }
                     throw err;
                 }
-                const pkgMoveFiles = moveFilesByPackage.get(pkgRoot) ?? [];
                 if (Object.keys(factsMap).length === 0 && pkgMoveFiles.length > 0) {
                     // Facts `{}` is ambiguous: syntax-broken packages return it as a
                     // SUCCESS (the compiler diagnostic only surfaces via
@@ -166,6 +234,14 @@ export function createMoveIngestPhase(client) {
                 for (const rel of pkgMoveFiles)
                     state.ingestedFiles.add(rel);
                 applyMapped(ctx.graph, mapFactsToGraph(factsMap, pkgRoot, ctx.repoPath), pkgRoot, state);
+                // Facts arrived, but move-flow serves structurally complete facts even
+                // for builds with compiler errors — and such builds silently lose the
+                // inference stage (`acquiresInferred`, hence ACQUIRES edges). Probe the
+                // build status so the degraded fidelity is surfaced, not implied away.
+                const status = await probePackageStatus(client, pkgRoot, hasStatusTool);
+                if (status && !status.ok) {
+                    packageIssues.push(degradedFactsIssue({ pkgRoot, diagnostics: status.diagnostics }));
+                }
             }
             // Pass 2+: link edges that need the full cross-package node index.
             linkCallEdges(ctx.graph, state);
@@ -175,10 +251,17 @@ export function createMoveIngestPhase(client) {
             linkFileModuleContains(ctx.graph, state);
             const output = toOutput(state, packageRoots);
             createMoveEntryPointEdges(ctx.graph, output);
-            const consistencyIssues = emptyFactsPackages.map(emptyFactsIssue);
+            const consistencyIssues = [
+                ...packageIssues,
+                ...emptyFactsPackages.map(emptyFactsIssue),
+            ];
             consistencyIssues.push(...validateMoveIngestOutput(ctx.graph, output));
             reportConsistencyIssues(ctx, consistencyIssues);
-            return { ...output, consistencyIssues };
+            return {
+                ...output,
+                consistencyIssues,
+                ingestWarnings: cliWarningsFromIssues(consistencyIssues),
+            };
         },
     };
 }

package/dist/core/run-analyze.d.ts

@@ -175,6 +175,12 @@ export interface AnalyzeResult {
      * the persisted meta surface the degraded state instead of reporting healthy.
      */
     ftsSkipped?: boolean;
+    /**
+     * Operator-actionable warnings from the standalone ingest phase (e.g. Move
+     * packages skipped or ingested at degraded fidelity). Rendered persistently
+     * in the CLI summary — same rationale as the FTS warning (#1161).
+     */
+    ingestWarnings?: readonly string[];
     /**
      * True when the index this run produced/validated is the flat workspace
      * slot (#2106 R2, inverted by #2354 to follow the checked-out branch).

package/dist/core/run-analyze.js

@@ -2091,6 +2091,7 @@ export async function runFullAnalysis(repoPath, options, callbacks, runnerIdenti
             stats: meta.stats,
             pipelineResult,
             ftsSkipped: !ftsReady,
+            ingestWarnings: pipelineResult.ingestWarnings,
             isPrimaryBranch: !placement.branch,
         };
     }

package/dist/types/pipeline.d.ts

@@ -34,4 +34,11 @@ export interface PipelineResult {
      * layer (if any) is resident in `graph` and persists via the whole-graph emit.
      */
     pdgEmitManifest?: PdgEmitManifest;
+    /**
+     * Operator-actionable warnings from the standalone ingest phase (skipped or
+     * degraded-fidelity packages). Passed through opaquely — the pipeline does
+     * not know which language produced them — so the CLI summary can render them
+     * persistently (same rationale as the FTS warning).
+     */
+    ingestWarnings?: readonly string[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.10-aptos.0",
+  "version": "1.6.10-aptos.1",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",