pumuki 6.3.289 → 6.3.291

package/VERSION

@@ -1 +1 @@
-6.3.289
+6.3.291

package/integrations/git/runPlatformGate.ts

@@ -108,12 +108,123 @@ const hasActionableFindingLocation = (finding: Finding): boolean => {
   );
 };
 
+const normalizeFindingLines = (lines: Finding['lines']): ReadonlyArray<number> => {
+  if (typeof lines === 'number') {
+    return Number.isFinite(lines) && lines > 0 ? [Math.trunc(lines)] : [];
+  }
+  if (Array.isArray(lines)) {
+    return [...new Set(lines.filter((line) => Number.isFinite(line) && line > 0).map((line) => Math.trunc(line)))].sort(
+      (left, right) => left - right
+    );
+  }
+  if (typeof lines === 'string') {
+    return [...new Set(
+      lines
+        .split(/[^0-9]+/)
+        .map((line) => Number.parseInt(line, 10))
+        .filter((line) => Number.isFinite(line) && line > 0)
+    )].sort((left, right) => left - right);
+  }
+  return [];
+};
+
+const parseChangedLinesByPathFromUnifiedDiff = (diff: string): Map<string, Set<number>> => {
+  const changedLinesByPath = new Map<string, Set<number>>();
+  let currentPath: string | undefined;
+
+  for (const rawLine of diff.split('\n')) {
+    if (rawLine.startsWith('+++ b/')) {
+      const nextPath = rawLine.slice('+++ b/'.length).trim();
+      currentPath = nextPath.length > 0 && nextPath !== '/dev/null' ? toNormalizedPath(nextPath) : undefined;
+      if (currentPath && !changedLinesByPath.has(currentPath)) {
+        changedLinesByPath.set(currentPath, new Set<number>());
+      }
+      continue;
+    }
+
+    if (!currentPath || !rawLine.startsWith('@@')) {
+      continue;
+    }
+
+    const hunkMatch = rawLine.match(/\+(\d+)(?:,(\d+))?/);
+    if (!hunkMatch) {
+      continue;
+    }
+    const startLine = Number.parseInt(hunkMatch[1] ?? '', 10);
+    const lineCount = hunkMatch[2] === undefined ? 1 : Number.parseInt(hunkMatch[2], 10);
+    if (!Number.isFinite(startLine) || startLine <= 0 || !Number.isFinite(lineCount)) {
+      continue;
+    }
+    const changedLines = changedLinesByPath.get(currentPath) ?? new Set<number>();
+    for (let offset = 0; offset < Math.max(0, lineCount); offset += 1) {
+      changedLines.add(startLine + offset);
+    }
+    changedLinesByPath.set(currentPath, changedLines);
+  }
+
+  return changedLinesByPath;
+};
+
+const collectStagedChangedLinesByPath = (
+  git: IGitService,
+  repoRoot: string
+): Map<string, Set<number>> => {
+  try {
+    return parseChangedLinesByPathFromUnifiedDiff(
+      git.runGit(['diff', '--cached', '--unified=0', '--no-ext-diff'], repoRoot)
+    );
+  } catch {
+    return new Map<string, Set<number>>();
+  }
+};
+
+const isFindingOutsideChangedLines = (
+  finding: Finding,
+  changedLinesByPath: ReadonlyMap<string, ReadonlySet<number>>
+): boolean => {
+  if (!finding.filePath) {
+    return false;
+  }
+  const changedLines = changedLinesByPath.get(toNormalizedPath(finding.filePath));
+  if (!changedLines || changedLines.size === 0) {
+    return false;
+  }
+  const findingLines = normalizeFindingLines(finding.lines);
+  if (findingLines.length === 0) {
+    return false;
+  }
+  return findingLines.every((line) => !changedLines.has(line));
+};
+
 const normalizeScopedRuleEngineFindings = (params: {
   findings: ReadonlyArray<Finding>;
   scope: GateScope;
+  stage: GatePolicy['stage'];
+  changedLinesByPath: ReadonlyMap<string, ReadonlySet<number>>;
 }): ReadonlyArray<Finding> => {
-  void params.scope;
-  return params.findings;
+  if (
+    (params.scope.kind !== 'staged' && params.scope.kind !== 'repoAndStaged') ||
+    (params.stage !== 'PRE_WRITE' && params.stage !== 'PRE_COMMIT')
+  ) {
+    return params.findings;
+  }
+
+  return params.findings.map((finding) => {
+    if (!isAstRuleFinding(finding) || !isFindingOutsideChangedLines(finding, params.changedLinesByPath)) {
+      return finding;
+    }
+    return {
+      ...finding,
+      blocking: false,
+      severity: 'INFO',
+      message:
+        `${finding.message} ` +
+        'Baseline brownfield outside the staged diff; tracked as advisory for this atomic slice.',
+      expected_fix:
+        finding.expected_fix ??
+        'Plan a dedicated brownfield remediation slice for this pre-existing finding.',
+    };
+  });
 };
 
 const buildDefaultMemoryShadowRecommendation = (params: {
@@ -988,6 +1099,7 @@ export async function runPlatformGate(params: {
     gateScopePathPrefixes
   );
   const stagedPaths = collectStagedPaths(git, repoRoot);
+  const stagedChangedLinesByPath = collectStagedChangedLinesByPath(git, repoRoot);
   const factsForPlatformEvaluation = shouldAugmentStagedSkillsContractFactsWithRepoFacts({
     scope: params.scope,
     facts,
@@ -1039,6 +1151,8 @@ export async function runPlatformGate(params: {
   const scopedRuleEngineFindings = normalizeScopedRuleEngineFindings({
     findings: ruleEngineFindings,
     scope: params.scope,
+    stage: params.policy.stage,
+    changedLinesByPath: stagedChangedLinesByPath,
   });
   const findings = [...aiGateRepoPolicyFindings, ...scopedRuleEngineFindings];
   const evaluationMetrics: SnapshotEvaluationMetrics = coverage

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.289",
+  "version": "6.3.291",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {