pumuki 6.3.10 → 6.3.12

package/README.md

@@ -104,6 +104,7 @@ npx --yes pumuki remove
 ```
 
 `pumuki remove` performs managed uninstall + artifact purge in one command.
+`npm uninstall pumuki` only removes the dependency from `package.json`; it does not remove managed hooks or lifecycle state.
 
 ## Lifecycle Commands
 
@@ -118,7 +119,8 @@ The `pumuki` binary provides repository lifecycle operations:
 | `pumuki doctor` | Safety checks (hook drift, tracked `node_modules`, lifecycle state) |
 | `pumuki status` | Current lifecycle snapshot |
 
-`pumuki remove` is dependency-safe by design: it never deletes non-Pumuki third-party dependencies.
+`pumuki remove` is dependency-safe by design: it never deletes non-Pumuki third-party dependencies and preserves pre-existing third-party empty directories.
+Use `pumuki remove` (or `pumuki uninstall --purge-artifacts` + `npm uninstall pumuki`) for complete teardown.
 
 ## Gate Commands
 
@@ -140,6 +142,7 @@ Dedicated gate binaries are available:
 - Rules are evaluated with platform-aware packs and project overrides.
 - Gate applies stage policy thresholds.
 - Evidence is generated as deterministic, machine-readable contract.
+- Findings carry deterministic traceability when available (`file`, `lines`, `matchedBy`, `source`).
 
 ### Default stage policies
 

package/VERSION

@@ -1 +1 @@
-v6.3.10
+v6.3.11

package/core/facts/detectors/text/ios.test.ts

@@ -3,9 +3,20 @@ import test from 'node:test';
 import {
   hasSwiftAnyViewUsage,
   hasSwiftCallbackStyleSignature,
+  hasSwiftDispatchGroupUsage,
+  hasSwiftDispatchQueueUsage,
+  hasSwiftDispatchSemaphoreUsage,
   hasSwiftForceCastUsage,
   hasSwiftForceTryUsage,
   hasSwiftForceUnwrap,
+  hasSwiftNavigationViewUsage,
+  hasSwiftObservableObjectUsage,
+  hasSwiftOnTapGestureUsage,
+  hasSwiftOperationQueueUsage,
+  hasSwiftStringFormatUsage,
+  hasSwiftTaskDetachedUsage,
+  hasSwiftUIScreenMainBoundsUsage,
+  hasSwiftUncheckedSendableUsage,
 } from './ios';
 
 test('hasSwiftForceUnwrap detecta force unwrap postfix en expresiones', () => {
@@ -81,3 +92,66 @@ test('hasSwiftCallbackStyleSignature ignora usos fuera de firmas callback', () =
   const source = `\n// @escaping completion: @escaping () -> Void\nlet text = "@escaping completion: @escaping () -> Void"\n`;
   assert.equal(hasSwiftCallbackStyleSignature(source), false);
 });
+
+test('detecta primitivas GCD y OperationQueue en codigo ejecutable', () => {
+  const source = `
+DispatchQueue.main.async { }
+DispatchGroup()
+DispatchSemaphore(value: 1)
+OperationQueue()
+`;
+
+  assert.equal(hasSwiftDispatchQueueUsage(source), true);
+  assert.equal(hasSwiftDispatchGroupUsage(source), true);
+  assert.equal(hasSwiftDispatchSemaphoreUsage(source), true);
+  assert.equal(hasSwiftOperationQueueUsage(source), true);
+});
+
+test('hasSwiftTaskDetachedUsage detecta Task.detached y evita Task normal', () => {
+  const positive = `
+Task.detached(priority: .background) { }
+`;
+  const negative = `
+Task {
+  await work()
+}
+`;
+  assert.equal(hasSwiftTaskDetachedUsage(positive), true);
+  assert.equal(hasSwiftTaskDetachedUsage(negative), false);
+});
+
+test('hasSwiftUncheckedSendableUsage detecta @unchecked Sendable', () => {
+  const source = `
+final class LegacyBox: @unchecked Sendable {}
+`;
+  assert.equal(hasSwiftUncheckedSendableUsage(source), true);
+});
+
+test('detectores SwiftUI modernos detectan patrones legacy relevantes', () => {
+  const source = `
+final class LegacyViewModel: ObservableObject {}
+NavigationView { Text("x") }
+Text("Tap").onTapGesture { }
+let value = String(format: "%d", 1)
+let width = UIScreen.main.bounds.width
+`;
+  assert.equal(hasSwiftObservableObjectUsage(source), true);
+  assert.equal(hasSwiftNavigationViewUsage(source), true);
+  assert.equal(hasSwiftOnTapGestureUsage(source), true);
+  assert.equal(hasSwiftStringFormatUsage(source), true);
+  assert.equal(hasSwiftUIScreenMainBoundsUsage(source), true);
+});
+
+test('detectores legacy ignoran strings y comentarios', () => {
+  const source = `
+// Task.detached { }
+let a = "Task.detached { }"
+let b = "NavigationView { }"
+let c = "String(format: \\\"%d\\\", 1)"
+let d = "UIScreen.main.bounds.width"
+`;
+  assert.equal(hasSwiftTaskDetachedUsage(source), false);
+  assert.equal(hasSwiftNavigationViewUsage(source), false);
+  assert.equal(hasSwiftStringFormatUsage(source), false);
+  assert.equal(hasSwiftUIScreenMainBoundsUsage(source), false);
+});

package/core/facts/detectors/text/ios.ts

@@ -67,6 +67,151 @@ export const hasSwiftAnyViewUsage = (source: string): boolean => {
   });
 };
 
+export const hasSwiftDispatchQueueUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'D' || !hasIdentifierAt(swiftSource, index, 'DispatchQueue')) {
+      return false;
+    }
+
+    const dotIndex = nextNonWhitespaceIndex(swiftSource, index + 'DispatchQueue'.length);
+    return dotIndex >= 0 && swiftSource[dotIndex] === '.';
+  });
+};
+
+export const hasSwiftDispatchGroupUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'D') {
+      return false;
+    }
+
+    return hasIdentifierAt(swiftSource, index, 'DispatchGroup');
+  });
+};
+
+export const hasSwiftDispatchSemaphoreUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'D') {
+      return false;
+    }
+
+    return hasIdentifierAt(swiftSource, index, 'DispatchSemaphore');
+  });
+};
+
+export const hasSwiftOperationQueueUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'O') {
+      return false;
+    }
+
+    return hasIdentifierAt(swiftSource, index, 'OperationQueue');
+  });
+};
+
+export const hasSwiftTaskDetachedUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'T' || !hasIdentifierAt(swiftSource, index, 'Task')) {
+      return false;
+    }
+
+    const dotIndex = nextNonWhitespaceIndex(swiftSource, index + 'Task'.length);
+    if (dotIndex < 0 || swiftSource[dotIndex] !== '.') {
+      return false;
+    }
+
+    const detachedIndex = nextNonWhitespaceIndex(swiftSource, dotIndex + 1);
+    return detachedIndex >= 0 && hasIdentifierAt(swiftSource, detachedIndex, 'detached');
+  });
+};
+
+export const hasSwiftUncheckedSendableUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== '@' || !swiftSource.startsWith('@unchecked', index)) {
+      return false;
+    }
+
+    const sendableIndex = nextNonWhitespaceIndex(swiftSource, index + '@unchecked'.length);
+    return sendableIndex >= 0 && hasIdentifierAt(swiftSource, sendableIndex, 'Sendable');
+  });
+};
+
+export const hasSwiftObservableObjectUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'O') {
+      return false;
+    }
+
+    return hasIdentifierAt(swiftSource, index, 'ObservableObject');
+  });
+};
+
+export const hasSwiftNavigationViewUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'N') {
+      return false;
+    }
+
+    return hasIdentifierAt(swiftSource, index, 'NavigationView');
+  });
+};
+
+export const hasSwiftOnTapGestureUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'o') {
+      return false;
+    }
+
+    return hasIdentifierAt(swiftSource, index, 'onTapGesture');
+  });
+};
+
+export const hasSwiftStringFormatUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'S' || !hasIdentifierAt(swiftSource, index, 'String')) {
+      return false;
+    }
+
+    const openingParenIndex = nextNonWhitespaceIndex(swiftSource, index + 'String'.length);
+    if (openingParenIndex < 0 || swiftSource[openingParenIndex] !== '(') {
+      return false;
+    }
+
+    const formatIndex = nextNonWhitespaceIndex(swiftSource, openingParenIndex + 1);
+    if (formatIndex < 0 || !hasIdentifierAt(swiftSource, formatIndex, 'format')) {
+      return false;
+    }
+
+    const colonIndex = nextNonWhitespaceIndex(swiftSource, formatIndex + 'format'.length);
+    return colonIndex >= 0 && swiftSource[colonIndex] === ':';
+  });
+};
+
+export const hasSwiftUIScreenMainBoundsUsage = (source: string): boolean => {
+  return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
+    if (current !== 'U' || !hasIdentifierAt(swiftSource, index, 'UIScreen')) {
+      return false;
+    }
+
+    const dotMainIndex = nextNonWhitespaceIndex(swiftSource, index + 'UIScreen'.length);
+    if (dotMainIndex < 0 || swiftSource[dotMainIndex] !== '.') {
+      return false;
+    }
+
+    const mainIndex = nextNonWhitespaceIndex(swiftSource, dotMainIndex + 1);
+    if (mainIndex < 0 || !hasIdentifierAt(swiftSource, mainIndex, 'main')) {
+      return false;
+    }
+
+    const dotBoundsIndex = nextNonWhitespaceIndex(swiftSource, mainIndex + 'main'.length);
+    if (dotBoundsIndex < 0 || swiftSource[dotBoundsIndex] !== '.') {
+      return false;
+    }
+
+    const boundsIndex = nextNonWhitespaceIndex(swiftSource, dotBoundsIndex + 1);
+    return boundsIndex >= 0 && hasIdentifierAt(swiftSource, boundsIndex, 'bounds');
+  });
+};
+
 export const hasSwiftForceTryUsage = (source: string): boolean => {
   return scanCodeLikeSource(source, ({ source: swiftSource, index, current }) => {
     if (current !== 't' || !hasIdentifierAt(swiftSource, index, 'try')) {

package/core/facts/detectors/typescript/index.test.ts

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import {
   hasAsyncPromiseExecutor,
+  hasConcreteDependencyInstantiation,
   hasConsoleErrorCall,
   hasConsoleLogCall,
   hasDebuggerStatement,
@@ -9,9 +10,14 @@ import {
   hasEmptyCatchClause,
   hasEvalCall,
   hasExplicitAnyType,
+  hasFrameworkDependencyImport,
   hasFunctionConstructorUsage,
+  hasMixedCommandQueryClass,
+  hasMixedCommandQueryInterface,
+  hasOverrideMethodThrowingNotImplemented,
   hasSetIntervalStringCallback,
   hasSetTimeoutStringCallback,
+  hasTypeDiscriminatorSwitch,
   hasWithStatement,
 } from './index';
 
@@ -229,3 +235,144 @@ test('hasDebuggerStatement detecta nodos debugger', () => {
   assert.equal(hasDebuggerStatement(debuggerAst), true);
   assert.equal(hasDebuggerStatement(noDebuggerAst), false);
 });
+
+test('hasMixedCommandQueryClass detecta mezcla command/query en la misma clase', () => {
+  const mixedClassAst = {
+    type: 'ClassDeclaration',
+    body: {
+      type: 'ClassBody',
+      body: [
+        { type: 'ClassMethod', key: { type: 'Identifier', name: 'getById' } },
+        { type: 'ClassMethod', key: { type: 'Identifier', name: 'save' } },
+      ],
+    },
+  };
+  const queryOnlyClassAst = {
+    type: 'ClassDeclaration',
+    body: {
+      type: 'ClassBody',
+      body: [{ type: 'ClassMethod', key: { type: 'Identifier', name: 'getById' } }],
+    },
+  };
+
+  assert.equal(hasMixedCommandQueryClass(mixedClassAst), true);
+  assert.equal(hasMixedCommandQueryClass(queryOnlyClassAst), false);
+});
+
+test('hasMixedCommandQueryInterface detecta mezcla command/query en la misma interfaz', () => {
+  const mixedInterfaceAst = {
+    type: 'TSInterfaceDeclaration',
+    body: {
+      type: 'TSInterfaceBody',
+      body: [
+        { type: 'TSMethodSignature', key: { type: 'Identifier', name: 'findById' } },
+        { type: 'TSMethodSignature', key: { type: 'Identifier', name: 'create' } },
+      ],
+    },
+  };
+  const queryOnlyInterfaceAst = {
+    type: 'TSInterfaceDeclaration',
+    body: {
+      type: 'TSInterfaceBody',
+      body: [{ type: 'TSMethodSignature', key: { type: 'Identifier', name: 'findById' } }],
+    },
+  };
+
+  assert.equal(hasMixedCommandQueryInterface(mixedInterfaceAst), true);
+  assert.equal(hasMixedCommandQueryInterface(queryOnlyInterfaceAst), false);
+});
+
+test('hasTypeDiscriminatorSwitch detecta switch por tipo/kind con multiples cases', () => {
+  const switchAst = {
+    type: 'SwitchStatement',
+    discriminant: {
+      type: 'MemberExpression',
+      computed: false,
+      object: { type: 'Identifier', name: 'event' },
+      property: { type: 'Identifier', name: 'kind' },
+    },
+    cases: [
+      { type: 'SwitchCase', test: { type: 'StringLiteral', value: 'a' } },
+      { type: 'SwitchCase', test: { type: 'StringLiteral', value: 'b' } },
+    ],
+  };
+  const nonDiscriminatorAst = {
+    type: 'SwitchStatement',
+    discriminant: { type: 'Identifier', name: 'index' },
+    cases: [
+      { type: 'SwitchCase', test: { type: 'NumericLiteral', value: 1 } },
+      { type: 'SwitchCase', test: { type: 'NumericLiteral', value: 2 } },
+    ],
+  };
+
+  assert.equal(hasTypeDiscriminatorSwitch(switchAst), true);
+  assert.equal(hasTypeDiscriminatorSwitch(nonDiscriminatorAst), false);
+});
+
+test('hasOverrideMethodThrowingNotImplemented detecta override con throw not implemented', () => {
+  const overrideThrowAst = {
+    type: 'ClassMethod',
+    override: true,
+    body: {
+      type: 'BlockStatement',
+      body: [
+        {
+          type: 'ThrowStatement',
+          argument: {
+            type: 'NewExpression',
+            callee: { type: 'Identifier', name: 'Error' },
+            arguments: [{ type: 'StringLiteral', value: 'Not implemented' }],
+          },
+        },
+      ],
+    },
+  };
+  const overrideValidAst = {
+    type: 'ClassMethod',
+    override: true,
+    body: {
+      type: 'BlockStatement',
+      body: [{ type: 'ReturnStatement', argument: { type: 'NumericLiteral', value: 1 } }],
+    },
+  };
+
+  assert.equal(hasOverrideMethodThrowingNotImplemented(overrideThrowAst), true);
+  assert.equal(hasOverrideMethodThrowingNotImplemented(overrideValidAst), false);
+});
+
+test('hasFrameworkDependencyImport detecta import/require de frameworks concretos', () => {
+  const importAst = {
+    type: 'ImportDeclaration',
+    source: { type: 'StringLiteral', value: '@nestjs/common' },
+  };
+  const requireAst = {
+    type: 'CallExpression',
+    callee: { type: 'Identifier', name: 'require' },
+    arguments: [{ type: 'StringLiteral', value: '@prisma/client' }],
+  };
+  const localRequireAst = {
+    type: 'CallExpression',
+    callee: { type: 'Identifier', name: 'require' },
+    arguments: [{ type: 'StringLiteral', value: './local' }],
+  };
+
+  assert.equal(hasFrameworkDependencyImport(importAst), true);
+  assert.equal(hasFrameworkDependencyImport(requireAst), true);
+  assert.equal(hasFrameworkDependencyImport(localRequireAst), false);
+});
+
+test('hasConcreteDependencyInstantiation detecta instanciacion directa de dependencias concretas', () => {
+  const concreteAst = {
+    type: 'NewExpression',
+    callee: { type: 'Identifier', name: 'PrismaClient' },
+    arguments: [],
+  };
+  const localAst = {
+    type: 'NewExpression',
+    callee: { type: 'Identifier', name: 'LocalBuilder' },
+    arguments: [],
+  };
+
+  assert.equal(hasConcreteDependencyInstantiation(concreteAst), true);
+  assert.equal(hasConcreteDependencyInstantiation(localAst), false);
+});