gitnexus 1.6.8 → 1.6.9-rc.1

package/dist/core/ingestion/cfg/visitors/python-harvest.d.ts

@@ -109,10 +109,10 @@ export declare class PythonHarvester {
     /** >0 while walking a conditionally-evaluated subexpression — defs become may-defs. */
     private conditionalDepth;
     /**
-     * `call` node id → binding indices its single-target result is assigned to
-     * (`x = f()` ⇒ `[x]`). Populated just before the value walk reaches the call
-     * (see {@link registerResultDefs}) and consumed by {@link visitCall}. Mirrors
-     * the Go harvester's `resultDefTargets`.
+     * `call` node id → binding indices its result is assigned to (`x = f()` ⇒
+     * `[x]`, `a, b = f()` ⇒ `[a, b]`). Populated just before the value walk reaches
+     * the call (see {@link registerResultDefs}) and consumed by {@link visitCall}.
+     * Mirrors the Go harvester's `resultDefTargets`.
      */
     private readonly resultDefTargets;
     constructor(fnNode: SyntaxNode);
@@ -184,13 +184,9 @@ export declare class PythonHarvester {
      * (it reads outer names), the body/filter after the targets are bound.
      */
     private walkComprehension;
-    /**
-     * When `value`'s root (after stripping parens) is a `call`, remember that
-     * call site should carry `resultDefs` — the binding indices of `targets`
-     * (def-position identifiers). Consumed by {@link visitCall} once the value
-     * walk reaches the node. Single-target only (the caller restricts to a plain
-     * identifier LHS); the blank identifier (`_`) binds nothing and is skipped.
-     */
+    /** Binding indices assigned by a target pattern, without mutating statement facts. */
+    private targetDefIndices;
+    /** Record result defs for a call-valued assignment. */
     private registerResultDefs;
     /** Strip `parenthesized_expression` wrappers around a value (`(f())`). */
     private unwrapValue;
@@ -201,6 +197,8 @@ export declare class PythonHarvester {
      * Python has no `new` — every site is `kind: 'call'`.
      */
     private visitCall;
+    /** Walk arguments, assigning only positional values to positional sink slots. */
+    private walkArgs;
     /**
      * `attribute` chain walk shared by value position and callee position. Records
      * the chain-root identifier as a use (identical to the old default descent)

package/dist/core/ingestion/cfg/visitors/python-harvest.js

@@ -15,10 +15,10 @@ export class PythonHarvester {
     /** >0 while walking a conditionally-evaluated subexpression — defs become may-defs. */
     conditionalDepth = 0;
     /**
-     * `call` node id → binding indices its single-target result is assigned to
-     * (`x = f()` ⇒ `[x]`). Populated just before the value walk reaches the call
-     * (see {@link registerResultDefs}) and consumed by {@link visitCall}. Mirrors
-     * the Go harvester's `resultDefTargets`.
+     * `call` node id → binding indices its result is assigned to (`x = f()` ⇒
+     * `[x]`, `a, b = f()` ⇒ `[a, b]`). Populated just before the value walk reaches
+     * the call (see {@link registerResultDefs}) and consumed by {@link visitCall}.
+     * Mirrors the Go harvester's `resultDefTargets`.
      */
     resultDefTargets = new Map();
     constructor(fnNode) {
@@ -124,8 +124,20 @@ export class PythonHarvester {
      */
     prescan(node) {
         const t = node.type;
-        if (NESTED_FUNCTION_TYPES.has(t) && node.id !== this.fnId)
+        if (NESTED_FUNCTION_TYPES.has(t) && node.id !== this.fnId) {
+            if (t === 'function_definition') {
+                const name = node.childForFieldName('name');
+                if (name?.type === 'identifier')
+                    this.declare(name, 'function');
+            }
             return;
+        }
+        if (t === 'class_definition') {
+            const name = node.childForFieldName('name');
+            if (name?.type === 'identifier')
+                this.declare(name, 'class');
+            return;
+        }
         switch (t) {
             case 'global_statement':
             case 'nonlocal_statement': {
@@ -469,10 +481,10 @@ export class PythonHarvester {
                 const left = node.childForFieldName('left');
                 const right = node.childForFieldName('right');
                 // Register result-defs BEFORE walking the value so the nested call site
-                // (reached during the value walk) carries them — single identifier
-                // target only (`x = f()`); a tuple/attribute LHS attaches nothing.
-                if (left?.type === 'identifier' && right)
-                    this.registerResultDefs(right, [left]);
+                // (reached during the value walk) carries them. Plain and unpack targets
+                // are preserved; attribute/subscript LHS attaches nothing.
+                if (left && right)
+                    this.registerResultDefs(right, this.targetDefIndices(left));
                 if (right)
                     this.walkValue(right, acc);
                 if (left)
@@ -500,8 +512,9 @@ export class PythonHarvester {
                 // walrus `(n := v)` — `n` is a def, `v` a use.
                 const name = node.childForFieldName('name');
                 const value = node.childForFieldName('value');
-                if (name?.type === 'identifier' && value)
-                    this.registerResultDefs(value, [name]);
+                if (name?.type === 'identifier' && value) {
+                    this.registerResultDefs(value, this.targetDefIndices(name));
+                }
                 if (value)
                     this.walkValue(value, acc);
                 if (name?.type === 'identifier')
@@ -607,27 +620,34 @@ export class PythonHarvester {
         if (body)
             this.walkValue(body, acc);
     }
-    // ── taint-site harvest (#2227 follow-up) ─────────────────────────────────
-    /**
-     * When `value`'s root (after stripping parens) is a `call`, remember that
-     * call site should carry `resultDefs` — the binding indices of `targets`
-     * (def-position identifiers). Consumed by {@link visitCall} once the value
-     * walk reaches the node. Single-target only (the caller restricts to a plain
-     * identifier LHS); the blank identifier (`_`) binds nothing and is skipped.
-     */
-    registerResultDefs(value, targets) {
-        const root = this.unwrapValue(value);
-        if (root.type !== 'call')
-            return;
-        const defs = [];
-        for (const target of targets) {
-            if (target.type !== 'identifier' || target.text === '_')
-                continue;
-            defs.push(this.resolve(target));
+    /** Binding indices assigned by a target pattern, without mutating statement facts. */
+    targetDefIndices(target) {
+        if (target.type === 'identifier')
+            return target.text === '_' ? [] : [this.resolve(target)];
+        if (PATTERN_LIST_TYPES.has(target.type)) {
+            const out = [];
+            for (let i = 0; i < target.namedChildCount; i++) {
+                const c = target.namedChild(i);
+                if (c)
+                    out.push(...this.targetDefIndices(c));
+            }
+            return out;
         }
-        if (defs.length > 0)
-            this.resultDefTargets.set(root.id, defs);
+        if (target.type === 'list_splat_pattern') {
+            const id = target.namedChild(0);
+            return id ? this.targetDefIndices(id) : [];
+        }
+        return [];
+    }
+    /** Record result defs for a call-valued assignment. */
+    registerResultDefs(value, defs) {
+        if (defs.length === 0)
+            return;
+        const root = this.unwrapValue(value);
+        if (root.type === 'call')
+            this.resultDefTargets.set(root.id, [...defs]);
     }
+    // ── taint-site harvest (#2227 follow-up) ─────────────────────────────────
     /** Strip `parenthesized_expression` wrappers around a value (`(f())`). */
     unwrapValue(node) {
         let n = node;
@@ -681,31 +701,44 @@ export class PythonHarvester {
         const resultDefs = this.resultDefTargets.get(node.id);
         if (resultDefs !== undefined)
             acc.setSiteResultDefs(siteIdx, resultDefs);
-        if (argsNode) {
-            let pos = 0;
-            for (let i = 0; i < argsNode.namedChildCount; i++) {
-                const arg = argsNode.namedChild(i);
-                if (!arg || arg.type === 'comment')
-                    continue;
-                if (arg.type === 'list_splat' || arg.type === 'dictionary_splat') {
-                    // `f(*args)` / `f(**kw)` — a spread. Mark the first spread position so
-                    // the matcher degrades soundly; the inner value still walks.
-                    acc.setFrameArg(pos);
-                    acc.setSiteSpread(siteIdx, pos);
-                    const inner = arg.namedChild(0);
-                    if (inner)
-                        this.walkValue(inner, acc);
-                }
-                else {
-                    // Positional or `keyword_argument` — the `keyword_argument` case in
-                    // `walkValue` walks only its `value`, so the key name is not a use.
-                    acc.setFrameArg(pos);
-                    this.walkValue(arg, acc);
-                }
+        this.walkArgs(argsNode, acc, siteIdx);
+        acc.popFrame();
+    }
+    /** Walk arguments, assigning only positional values to positional sink slots. */
+    walkArgs(args, acc, siteIdx) {
+        if (!args)
+            return;
+        let pos = 0;
+        for (let i = 0; i < args.namedChildCount; i++) {
+            const arg = args.namedChild(i);
+            if (!arg || arg.type === 'comment')
+                continue;
+            if (arg.type === 'keyword_argument') {
+                const value = arg.childForFieldName('value');
+                // SiteRecord has no keyword-name metadata. Keep the value's ordinary
+                // uses/sources, but do not guess a positional sink slot from source order.
+                if (value)
+                    acc.suppressOccurrences(() => this.walkValue(value, acc));
+            }
+            else if (arg.type === 'list_splat') {
+                acc.setFrameArg(pos);
+                acc.setSiteSpread(siteIdx, pos);
+                const inner = arg.namedChild(0);
+                if (inner)
+                    this.walkValue(inner, acc);
+                pos++;
+            }
+            else if (arg.type === 'dictionary_splat') {
+                const inner = arg.namedChild(0);
+                if (inner)
+                    acc.suppressOccurrences(() => this.walkValue(inner, acc));
+            }
+            else {
+                acc.setFrameArg(pos);
+                this.walkValue(arg, acc);
                 pos++;
             }
         }
-        acc.popFrame();
     }
     /**
      * `attribute` chain walk shared by value position and callee position. Records

package/dist/core/ingestion/scope-resolution/pipeline/run.js

@@ -520,11 +520,11 @@ export function runScopeResolution(input, provider) {
         // ── M3 taint setup (#2083 U4) ────────────────────────────────────────
         // Explicit model-registration seam (idempotent, cheap) — the registry
         // stays empty on non-pdg runs, preserving default-run parity. The
-        // registry is keyed by `SupportedLanguages` enum VALUES ('typescript' /
-        // 'javascript'), and `ScopeResolver.language` IS a `SupportedLanguages`
-        // member registered under those same constants — the join is direct
-        // equality, no mapping table. A language without a registered spec
-        // (python, go, …) skips taint entirely: no work, no warn spam (KTD8).
+        // registry is keyed by SupportedLanguages enum values, and
+        // ScopeResolver.language is registered under those same constants -
+        // the join is direct equality, with no mapping table. A language without a
+        // registered spec (go, ruby, ...) skips taint entirely: no work, no warn spam
+        // (KTD8).
         registerBuiltinTaintModels();
         const taintSpec = getSourceSinkConfig(provider.language);
         // Taint-side solver fact cap: the SAME derivation emitFileReachingDefs

package/dist/core/ingestion/taint/python-model.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Built-in Python taint model (#2204 first slice).
+ *
+ * Keep the model intentionally conservative: import-aware sinks for standard
+ * library command execution, receiver-conventional database execution calls,
+ * and Flask/FastAPI-style request-object member reads. No sanitizers are
+ * registered yet because a false sanitizer kill can hide a real finding.
+ */
+import type { SourceSinkSanitizerSpec } from './source-sink-config.js';
+export declare const PYTHON_TAINT_MODEL: SourceSinkSanitizerSpec;

package/dist/core/ingestion/taint/python-model.js

@@ -0,0 +1,43 @@
+/**
+ * Built-in Python taint model (#2204 first slice).
+ *
+ * Keep the model intentionally conservative: import-aware sinks for standard
+ * library command execution, receiver-conventional database execution calls,
+ * and Flask/FastAPI-style request-object member reads. No sanitizers are
+ * registered yet because a false sanitizer kill can hide a real finding.
+ */
+export const PYTHON_TAINT_MODEL = {
+    sources: [
+        {
+            kind: 'remote-input',
+            objects: ['request', 'req'],
+            properties: [
+                'args',
+                'form',
+                'json',
+                'data',
+                'headers',
+                'cookies',
+                'path_params',
+                'query_params',
+            ],
+        },
+    ],
+    sinks: [
+        { name: 'system', kind: 'command-injection', args: [0], module: 'os' },
+        { name: 'popen', kind: 'command-injection', args: [0], module: 'os' },
+        { name: 'call', kind: 'command-injection', args: [0], module: 'subprocess' },
+        { name: 'run', kind: 'command-injection', args: [0], module: 'subprocess' },
+        { name: 'Popen', kind: 'command-injection', args: [0], module: 'subprocess' },
+        { name: 'check_call', kind: 'command-injection', args: [0], module: 'subprocess' },
+        { name: 'check_output', kind: 'command-injection', args: [0], module: 'subprocess' },
+        { name: 'eval', kind: 'code-injection', args: [0], global: true },
+        { name: 'exec', kind: 'code-injection', args: [0], global: true },
+        { name: 'open', kind: 'path-traversal', args: [0], global: true },
+        { name: 'query', kind: 'sql-injection', args: [0], anyReceiver: true },
+        { name: 'execute', kind: 'sql-injection', args: [0], anyReceiver: true },
+        { name: 'executemany', kind: 'sql-injection', args: [0], anyReceiver: true },
+        { name: 'executescript', kind: 'sql-injection', args: [0], anyReceiver: true },
+    ],
+    sanitizers: [],
+};

package/dist/core/ingestion/taint/typescript-model.d.ts

@@ -27,12 +27,20 @@ export declare const TS_JS_TAINT_MODEL: SourceSinkSanitizerSpec;
  * array order is semantic (entry identity) and intentionally preserved.
  */
 export declare function computeTaintModelVersion(spec: SourceSinkSanitizerSpec): string;
-/** Version stamp of the built-in TS/JS model (joins the RepoMeta pdg key in U5). */
+export declare const BUILTIN_TAINT_MODELS: {
+    readonly javascript: SourceSinkSanitizerSpec;
+    readonly python: SourceSinkSanitizerSpec;
+    readonly typescript: SourceSinkSanitizerSpec;
+};
+/**
+ * Version stamp of every built-in model (joins the RepoMeta pdg key in U5).
+ * Adding a language model must invalidate existing persisted taint findings.
+ */
 export declare const taintModelVersion: string;
 /**
- * Register the built-in model for TypeScript and JavaScript. Explicit init
- * seam for the U4 emit path (call before the pdg window consumes the
- * registry); idempotent. Vue and other TS-adjacent language ids are
- * deliberately NOT registered — the M3 scope is TS/JS only.
+ * Register the built-in models for TypeScript, JavaScript, and Python.
+ * Explicit init seam for the U4 emit path (call before the pdg window
+ * consumes the registry); idempotent. Other language ids remain unregistered
+ * until they have a dedicated model.
  */
 export declare function registerBuiltinTaintModels(): void;

package/dist/core/ingestion/taint/typescript-model.js

@@ -16,6 +16,7 @@
  */
 import { createHash } from 'node:crypto';
 import { SupportedLanguages } from '../../../_shared/index.js';
+import { PYTHON_TAINT_MODEL } from './python-model.js';
 import { registerSourceSinkConfig } from './source-sink-registry.js';
 /**
  * The built-in TS/JS model. Module provenance uses bare specifier names —
@@ -74,7 +75,10 @@ export const TS_JS_TAINT_MODEL = {
  * array order is semantic (entry identity) and intentionally preserved.
  */
 export function computeTaintModelVersion(spec) {
-    return createHash('sha256').update(canonicalJson(spec)).digest('hex').slice(0, 12);
+    return computeModelDigest(spec);
+}
+function computeModelDigest(value) {
+    return createHash('sha256').update(canonicalJson(value)).digest('hex').slice(0, 12);
 }
 function canonicalJson(value) {
     if (Array.isArray(value))
@@ -88,15 +92,24 @@ function canonicalJson(value) {
     }
     return JSON.stringify(value);
 }
-/** Version stamp of the built-in TS/JS model (joins the RepoMeta pdg key in U5). */
-export const taintModelVersion = computeTaintModelVersion(TS_JS_TAINT_MODEL);
+export const BUILTIN_TAINT_MODELS = {
+    [SupportedLanguages.JavaScript]: TS_JS_TAINT_MODEL,
+    [SupportedLanguages.Python]: PYTHON_TAINT_MODEL,
+    [SupportedLanguages.TypeScript]: TS_JS_TAINT_MODEL,
+};
+/**
+ * Version stamp of every built-in model (joins the RepoMeta pdg key in U5).
+ * Adding a language model must invalidate existing persisted taint findings.
+ */
+export const taintModelVersion = computeModelDigest(BUILTIN_TAINT_MODELS);
 /**
- * Register the built-in model for TypeScript and JavaScript. Explicit init
- * seam for the U4 emit path (call before the pdg window consumes the
- * registry); idempotent. Vue and other TS-adjacent language ids are
- * deliberately NOT registered — the M3 scope is TS/JS only.
+ * Register the built-in models for TypeScript, JavaScript, and Python.
+ * Explicit init seam for the U4 emit path (call before the pdg window
+ * consumes the registry); idempotent. Other language ids remain unregistered
+ * until they have a dedicated model.
  */
 export function registerBuiltinTaintModels() {
     registerSourceSinkConfig(SupportedLanguages.TypeScript, TS_JS_TAINT_MODEL);
     registerSourceSinkConfig(SupportedLanguages.JavaScript, TS_JS_TAINT_MODEL);
+    registerSourceSinkConfig(SupportedLanguages.Python, PYTHON_TAINT_MODEL);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.8",
+  "version": "1.6.9-rc.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",