@goodandready/dsh-approval-gate 0.1.22 → 0.1.24

package/lib/session-modes.js

@@ -0,0 +1,146 @@
+// lib/session-modes.js
+// Session-level Gate Mode Switching (#61).
+// Allows per-session mode switching between auto-approval, hybrid, manual, and strict modes.
+
+export const GATE_MODES = Object.freeze({
+  AUTO: "auto-approval",
+  MANUAL: "manual",
+  HYBRID: "hybrid",
+  STRICT: "strict",
+});
+
+export const PRESET_MODE_MAP = Object.freeze({
+  sandbox: GATE_MODES.AUTO,
+  test: GATE_MODES.AUTO,
+  auto: GATE_MODES.AUTO,
+  "auto-approval": GATE_MODES.AUTO,
+  prod: GATE_MODES.STRICT,
+  production: GATE_MODES.STRICT,
+  strict: GATE_MODES.STRICT,
+  manual: GATE_MODES.MANUAL,
+  dev: GATE_MODES.HYBRID,
+  development: GATE_MODES.HYBRID,
+  hybrid: GATE_MODES.HYBRID,
+  standard: GATE_MODES.HYBRID,
+});
+
+/**
+ * Resolves active gate mode for a session based on presets, context, or defaults.
+ *
+ * @param {string} [sessionId]
+ * @param {string} [sessionPreset]
+ * @param {Record<string, any>} [options]
+ * @returns {string}
+ */
+export function resolveSessionGateMode(sessionId, sessionPreset, options = {}) {
+  // 1. Explicit mode in options or context
+  if (options.mode && Object.values(GATE_MODES).includes(options.mode)) {
+    return options.mode;
+  }
+  if (options.sessionMode && Object.values(GATE_MODES).includes(options.sessionMode)) {
+    return options.sessionMode;
+  }
+
+  // 2. Preset mapping
+  const presetKey = String(sessionPreset || options.preset || "").toLowerCase().trim();
+  if (presetKey && PRESET_MODE_MAP[presetKey]) {
+    return PRESET_MODE_MAP[presetKey];
+  }
+
+  // 3. Fallback default
+  return options.defaultMode || GATE_MODES.HYBRID;
+}
+
+/**
+ * Applies session gate mode policy to a verdict decision (#61).
+ *
+ * @param {string} mode - Gate mode
+ * @param {Record<string, any>} decision - Original verdict decision
+ * @param {{ track?: string, riskBucket?: string, lockedAsk?: boolean, isRead?: boolean }} [meta]
+ * @returns {Record<string, any>}
+ */
+export function applySessionModePolicy(mode, decision, meta = {}) {
+  if (!decision) return decision;
+
+  const currentMode = mode || GATE_MODES.HYBRID;
+  const isLocked = Boolean(decision.lockedAsk || meta.lockedAsk);
+  const track = meta.track || decision.track || "external";
+  const riskBucket = meta.riskBucket || decision.riskBucket || "medium";
+
+  // Auto-approval mode: relaxes low-risk or internal chores that would otherwise ask
+  if (currentMode === GATE_MODES.AUTO && decision.verdict === "ask" && !isLocked) {
+    const isInternal = track === "internal";
+    const isLowRisk = riskBucket === "low" || riskBucket === "minimal";
+    if (isInternal || isLowRisk) {
+      return {
+        ...decision,
+        verdict: "allow",
+        autoApproved: true,
+        originalVerdict: "ask",
+        sessionMode: currentMode,
+        stage: "session-mode-auto",
+        autoReason: isInternal ? "auto-approve-internal-track" : "auto-approve-low-risk",
+      };
+    }
+  }
+
+  // Manual or strict mode: requires manual confirmation for external mutations or higher risk
+  if ((currentMode === GATE_MODES.MANUAL || currentMode === GATE_MODES.STRICT) && decision.verdict === "allow") {
+    const isSafeRead = Boolean(meta.isRead);
+    const isInternalSafe = track === "internal" && (riskBucket === "low" || riskBucket === "minimal");
+    if (!isSafeRead && !isInternalSafe) {
+      return {
+        ...decision,
+        verdict: "ask",
+        manualRequired: true,
+        originalVerdict: "allow",
+        sessionMode: currentMode,
+        stage: "session-mode-manual",
+        manualReason: currentMode === GATE_MODES.STRICT ? "strict-mode-enforcement" : "manual-mode-enforcement",
+      };
+    }
+  }
+
+  return {
+    ...decision,
+    sessionMode: currentMode,
+  };
+}
+
+/**
+ * Registry for maintaining per-session gate modes (#61).
+ */
+export class SessionModeRegistry {
+  constructor(defaultMode = GATE_MODES.HYBRID) {
+    this.defaultMode = defaultMode;
+    /** @type {Map<string, string>} */
+    this.sessionModes = new Map();
+  }
+
+  setMode(sessionId, mode) {
+    const key = sessionId || "default";
+    const resolved = PRESET_MODE_MAP[String(mode).toLowerCase().trim()] || mode;
+    if (Object.values(GATE_MODES).includes(resolved)) {
+      this.sessionModes.set(key, resolved);
+      return resolved;
+    }
+    return this.defaultMode;
+  }
+
+  getMode(sessionId, preset) {
+    const key = sessionId || "default";
+    if (this.sessionModes.has(key)) {
+      return this.sessionModes.get(key);
+    }
+    return resolveSessionGateMode(sessionId, preset, { defaultMode: this.defaultMode });
+  }
+
+  clearSession(sessionId) {
+    const key = sessionId || "default";
+    this.sessionModes.delete(key);
+  }
+
+  reset() {
+    this.sessionModes.clear();
+  }
+}

package/lib/similarity.js

@@ -0,0 +1,134 @@
+// lib/similarity.js
+// Semantic Command Similarity & Fast Validation (#85).
+// Normalizes and validates syntactic variations of commands (e.g. pnpm test vs npm run test vs npm test).
+// Provides canonical command normalization and optional fast Flash-model validator with deterministic fallback.
+
+const PKG_MGR_REGEX = /^(?:pnpm|npm|yarn|bun)\b/;
+
+/**
+ * Normalizes common command variants into canonical representation (#85).
+ *
+ * @param {string} command
+ * @returns {string}
+ */
+export function canonicalizeCommand(command) {
+  if (!command || typeof command !== "string") return "";
+  let cmd = command.trim().replace(/\s+/g, " ");
+
+  // 1. Package manager scripts normalization
+  // pnpm test / npm run test / yarn test / bun test -> npm test
+  if (/^(?:pnpm|npm\s+run|yarn|bun)\s+test\b/.test(cmd)) {
+    return cmd.replace(/^(?:pnpm|npm\s+run|yarn|bun)\s+test/, "npm test");
+  }
+  // pnpm run <script> / yarn <script> / bun run <script> -> npm run <script>
+  if (/^(?:pnpm\s+run|yarn\s+run|bun\s+run)\s+([a-zA-Z0-9_:.-]+)/.test(cmd)) {
+    return cmd.replace(/^(?:pnpm\s+run|yarn\s+run|bun\s+run)/, "npm run");
+  }
+  if (/^(?:pnpm|yarn|bun)\s+(build|lint|check|start|dev)\b/.test(cmd)) {
+    return cmd.replace(/^(?:pnpm|yarn|bun)\s+/, "npm run ");
+  }
+
+  // 2. Python testing tools
+  // python -m pytest / python3 -m pytest -> pytest
+  if (/^python[23]?\s+-m\s+pytest\b/.test(cmd)) {
+    return cmd.replace(/^python[23]?\s+-m\s+pytest/, "pytest");
+  }
+
+  // 3. Git status / diff flags
+  if (/^git\s+status\s+(?:-s|--short)\b/.test(cmd)) {
+    return "git status";
+  }
+  if (/^git\s+diff\s+HEAD\b/.test(cmd)) {
+    return "git diff";
+  }
+
+  return cmd;
+}
+
+/**
+ * Checks whether two commands are semantically equivalent (#85).
+ *
+ * @param {string} cmdA
+ * @param {string} cmdB
+ * @returns {{ equivalent: boolean, confidence: number, method: string }}
+ */
+export function isSemanticallyEquivalent(cmdA, cmdB) {
+  if (!cmdA || !cmdB) return { equivalent: false, confidence: 0, method: "none" };
+  const a = String(cmdA).trim();
+  const b = String(cmdB).trim();
+  if (a === b) {
+    return { equivalent: true, confidence: 1.0, method: "exact" };
+  }
+
+  const normA = canonicalizeCommand(a);
+  const normB = canonicalizeCommand(b);
+
+  if (normA && normA === normB) {
+    return { equivalent: true, confidence: 0.98, method: "canonical" };
+  }
+
+  return { equivalent: false, confidence: 0, method: "mismatch" };
+}
+
+/**
+ * Searches a list of learned rules for a semantically equivalent match (#85).
+ *
+ * @param {string} command
+ * @param {Array<{ command?: string, key?: string }>} learnedRules
+ * @returns {{ matched: boolean, matchedRule?: any, method?: string }}
+ */
+export function findSemanticallyEquivalentRule(command, learnedRules = []) {
+  if (!command || !Array.isArray(learnedRules) || learnedRules.length === 0) {
+    return { matched: false };
+  }
+
+  for (const rule of learnedRules) {
+    const ruleCmd = rule.command || (rule.key && rule.key.includes(":") ? rule.key.slice(rule.key.indexOf(":") + 1) : "");
+    if (!ruleCmd) continue;
+
+    const check = isSemanticallyEquivalent(command, ruleCmd);
+    if (check.equivalent) {
+      return { matched: true, matchedRule: rule, method: check.method };
+    }
+  }
+
+  return { matched: false };
+}
+
+/**
+ * Validates semantic similarity with optional Flash-model LLM client (#85).
+ * Falls back safely to deterministic canonical matching on error or absence.
+ *
+ * @param {string} cmdA
+ * @param {string} cmdB
+ * @param {{ classify?: Function, model?: string }} [llmClient]
+ * @returns {Promise<{ equivalent: boolean, confidence: number, method: string }>}
+ */
+export async function validateSemanticSimilarity(cmdA, cmdB, llmClient = null) {
+  // 1. Fast deterministic check
+  const det = isSemanticallyEquivalent(cmdA, cmdB);
+  if (det.equivalent) {
+    return det;
+  }
+
+  // 2. If no LLM client, return deterministic result
+  if (!llmClient || typeof llmClient.classify !== "function") {
+    return det;
+  }
+
+  try {
+    const prompt = `Are these two terminal commands semantically equivalent in purpose and safety?\nCommand 1: ${cmdA}\nCommand 2: ${cmdB}\nRespond with JSON: {"equivalent": true|false, "confidence": number}`;
+    const res = await llmClient.classify({ name: "semantic_check", prompt });
+    if (res && typeof res.equivalent === "boolean") {
+      return {
+        equivalent: res.equivalent,
+        confidence: typeof res.confidence === "number" ? res.confidence : 0.9,
+        method: "flash-model",
+      };
+    }
+  } catch (_err) {
+    // Fail closed to deterministic fallback
+  }
+
+  return det;
+}

package/package.json

@@ -1,55 +1,60 @@
-{
-  "name": "@goodandready/dsh-approval-gate",
-  "version": "0.1.22",
-  "description": "Host-only command safety gate for DeepSeek Harness: blocks recognized dangerous operations and requests DSH approval when a command cannot be inspected.",
-  "type": "module",
-  "main": "lib/index.js",
-  "exports": {
-    ".": "./lib/index.js",
-    "./package.json": "./package.json",
-    "./cordis.patch.yml": "./cordis.patch.yml"
-  },
-  "files": [
-    "lib",
-    "rules",
-    "cordis.patch.yml",
-    "README.md",
-    "README.zh.md",
-    "README.ru.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ],
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
-  },
-  "license": "MIT",
-  "peerDependencies": {
-    "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/schemastery": "^3.18.1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/GooDAnDReaDY/dsh-approval-gate.git"
-  },
-  "homepage": "https://github.com/GooDAnDReaDY/dsh-approval-gate#readme",
-  "bugs": {
-    "url": "https://github.com/GooDAnDReaDY/dsh-approval-gate/issues"
-  },
-  "scripts": {
-    "test": "node --test test/*.test.mjs"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public"
-  },
-  "keywords": [
-    "dsh",
-    "dsh-plugin",
-    "deepseek-harness",
-    "security",
-    "approval-gate",
-    "safety"
-  ]
-}
+{
+  "name": "@goodandready/dsh-approval-gate",
+  "version": "0.1.24",
+  "description": "Host-only command safety gate for DeepSeek Harness: blocks recognized dangerous operations and requests DSH approval when a command cannot be inspected.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": [
+    "lib",
+    "rules",
+    "cordis.patch.yml",
+    "README.md",
+    "README.zh.md",
+    "README.ru.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "bin"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GooDAnDReaDY/dsh-approval-gate.git"
+  },
+  "homepage": "https://github.com/GooDAnDReaDY/dsh-approval-gate#readme",
+  "bugs": {
+    "url": "https://github.com/GooDAnDReaDY/dsh-approval-gate/issues"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "eval": "node bin/eval.mjs"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "security",
+    "approval-gate",
+    "safety"
+  ],
+  "bin": {
+    "dsh-approval-eval": "./bin/eval.mjs"
+  }
+}