opencode-wait-a-minute 0.0.0-stage → 1.1.0-rc.8

package/src/policy/strategy-capabilities.js

@@ -0,0 +1,211 @@
+// policy/strategy-capabilities.js
+// Structured capability binding for strategy/policy evaluation.
+//
+// Replaces loose substring matching (e.g. actionLower.includes(allowed)) with
+// structured capability records that bind an action/tool to a precise scope.
+//
+// Capability shapes:
+//
+//   { capability: "action.execute", action: "edit" }                        ← exact action
+//   { capability: "action.execute", action: "edit", tool: "edit_file" }     ← action+tool
+//
+//   { capability: "command.execute",
+//     executable: "npm",
+//     argsPattern: ["test"] }                                               ← command + argv prefix
+//   { capability: "command.execute",
+//     executable: "npm",
+//     argsPattern: ["run", "lint"] }                                        ← argv-prefix match
+//   { capability: "command.execute",
+//     executable: /^[a-z0-9_-]+$/i }                                        ← regex on name
+//
+//   { capability: "filesystem.write", scope: "src/**" }                     ← glob scope
+//   { capability: "filesystem.write", scope: "src/**", deny: ["**/*.env"] }
+//   { capability: "filesystem.read",  scope: ["docs/**", "src/**"] }
+//
+// Matching rules:
+//   - exact match (string === string) for action / executable / scope-literal
+//   - regex (RegExp) when the value is a RegExp
+//   - glob (micromatch-style, `*` and `**` supported via small builtin matcher)
+//   - argsPattern: array of tokens matched against argv in order; a leading
+//     wildcard token "*" consumes any single argv slot.
+//
+// A capability is considered covered if and only if every required field
+// matches the candidate. Missing optional fields on the candidate do not
+// cause a non-match (they only narrow on the capability side).
+
+// ---------- glob matcher (small, dependency-free) ----------
+
+function globToRegExp(glob) {
+  // Escape regex special chars except for * and ? and **.
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        re += ".*";
+        i++;
+        if (glob[i + 1] === "/") i++; // consume optional trailing slash
+      } else {
+        re += "[^/]*";
+      }
+    } else if (c === "?") {
+      re += "[^/]";
+    } else if ("\\^$.|+()[]{}".includes(c)) {
+      re += "\\" + c;
+    } else {
+      re += c;
+    }
+  }
+  return new RegExp("^" + re + "$");
+}
+
+function matchGlob(value, pattern) {
+  if (typeof value !== "string" || typeof pattern !== "string") return false;
+  return globToRegExp(pattern).test(value);
+}
+
+// ---------- low-level value match ----------
+
+function matchValue(actual, expected) {
+  if (expected instanceof RegExp) {
+    return typeof actual === "string" && expected.test(actual);
+  }
+  if (typeof expected === "string") {
+    if (typeof actual !== "string") return false;
+    // exact match only — substring is rejected by design
+    return actual === expected;
+  }
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) return false;
+    if (actual.length !== expected.length) return false;
+    for (let i = 0; i < expected.length; i++) {
+      if (!matchValue(actual[i], expected[i])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+// ---------- argv pattern matching ----------
+
+// Pattern is an array of tokens (strings). Supports "*" as a single-segment
+// wildcard that consumes exactly one argv slot. Does NOT do substring or
+// loose matching.
+function matchArgsPattern(argv, pattern) {
+  if (!Array.isArray(argv) || !Array.isArray(pattern)) return false;
+  if (pattern.length > argv.length) return false;
+  for (let i = 0; i < pattern.length; i++) {
+    const tok = pattern[i];
+    if (tok === "*") continue; // consume one slot, value unchecked
+    if (tok instanceof RegExp) {
+      if (typeof argv[i] !== "string" || !tok.test(argv[i])) return false;
+      continue;
+    }
+    if (tok !== argv[i]) return false;
+  }
+  return true;
+}
+
+// ---------- capability dispatch ----------
+
+function matchActionCapability(cap, candidate) {
+  // candidate: { action, tool }
+  if (cap.action !== undefined && !matchValue(candidate.action, cap.action)) return false;
+  if (cap.tool !== undefined && !matchValue(candidate.tool, cap.tool)) return false;
+  return true;
+}
+
+function matchCommandCapability(cap, candidate) {
+  // candidate: { executable, args }
+  if (cap.executable === undefined && cap.argsPattern === undefined) return false;
+  if (cap.executable !== undefined) {
+    if (!matchValue(candidate.executable, cap.executable)) return false;
+  }
+  if (cap.argsPattern !== undefined) {
+    const argv = Array.isArray(candidate.args) ? candidate.args : [];
+    if (!matchArgsPattern(argv, cap.argsPattern)) return false;
+  }
+  return true;
+}
+
+function matchFilesystemCapability(cap, candidate) {
+  // candidate: { path, operation: "read" | "write" | "delete" | ... }
+  if (cap.scope === undefined) return false;
+  const paths = Array.isArray(cap.scope) ? cap.scope : [cap.scope];
+  const target = typeof candidate.path === "string" ? candidate.path : "";
+  let matched = false;
+  for (const pat of paths) {
+    if (matchGlob(target, pat)) { matched = true; break; }
+  }
+  if (!matched) return false;
+  if (Array.isArray(cap.deny)) {
+    for (const deny of cap.deny) {
+      if (matchGlob(target, deny)) return false; // explicit deny wins
+    }
+  }
+  return true;
+}
+
+// ---------- public API ----------
+
+/**
+ * Match a single capability against a candidate descriptor.
+ * @param {object} cap      capability record
+ * @param {object} candidate descriptor of the action being evaluated
+ * @returns {boolean}
+ */
+export function matchesCapability(cap, candidate) {
+  if (!cap || typeof cap !== "object" || !candidate) return false;
+  const kind = cap.capability;
+  if (kind === "action.execute")    return matchActionCapability(cap, candidate);
+  if (kind === "command.execute")   return matchCommandCapability(cap, candidate);
+  if (kind === "filesystem.read" ||
+      kind === "filesystem.write" ||
+      kind === "filesystem.delete") return matchFilesystemCapability(cap, candidate);
+  return false;
+}
+
+/**
+ * Classify an action against a list of structured capabilities.
+ *
+ * @param {object} candidate descriptor (action/tool/executable/args/path/...)
+ * @param {object} capabilities { allowed: Capability[], prohibited: Capability[] }
+ * @returns {{ allowed: boolean, reason: string }}
+ *
+ * Order of evaluation:
+ *   1. Any matching prohibited capability → allowed=false, blocked.
+ *   2. Any matching allowed capability    → allowed=true, covered.
+ *   3. Otherwise                          → allowed=false, not covered.
+ *
+ * Loose string substring matching is intentionally NOT supported here.
+ */
+export function classifyByCapabilities(candidate, capabilities) {
+  if (!capabilities || typeof capabilities !== "object") {
+    return { allowed: false, reason: "no-capability-spec" };
+  }
+  const prohibited = Array.isArray(capabilities.prohibited) ? capabilities.prohibited : [];
+  for (const cap of prohibited) {
+    if (matchesCapability(cap, candidate)) {
+      return { allowed: false, reason: `prohibited-capability:${cap.capability}` };
+    }
+  }
+  const allowed = Array.isArray(capabilities.allowed) ? capabilities.allowed : [];
+  for (const cap of allowed) {
+    if (matchesCapability(cap, candidate)) {
+      return { allowed: true, reason: `allowed-capability:${cap.capability}` };
+    }
+  }
+  return { allowed: false, reason: "no-matching-capability" };
+}
+
+/**
+ * Convenience: build a normalized candidate from a raw (action, tool, args)
+ * triplet the way index.js classifies it today, so call sites don't have to.
+ */
+export function buildCandidate({ action, tool, args }) {
+  const cmd = String(args?.command || args?.cmd || args?.script || "");
+  const argv = cmd.length > 0 ? cmd.split(/\s+/) : [];
+  const executable = argv[0] || "";
+  const rest = argv.slice(1);
+  return { action, tool, executable, args: rest, path: args?.path || args?.filePath };
+}

package/src/policy/strategy.js

@@ -0,0 +1,6 @@
+export function createStrategy(name, rules) {
+  return { name, rules, status: "PROPOSED", createdAt: Date.now() };
+}
+export function validateStrategy(strategy) {
+  return strategy && strategy.name && strategy.rules;
+}

package/src/policy/uncertainty.js

@@ -0,0 +1,117 @@
+/**
+ * Clasifica la incertidumbre de una tarea.
+ * Rule-based, determinista (sin LLM). Prioridad de seguridad: critical > resolvable > non-blocking.
+ */
+export function classifyUncertainty(item = "") {
+  const text = String(item);
+  const CRITICAL = [
+    /migra|migrate|migraci[oó]n|refresh.?token|rotar|dele|destructiv|borr|elim|data loss|p[ée]rdida de datos/i,
+    /seguridad|security|auth|oauth|token|api.?key|secret|password/i,
+    /schema|esquema|api contract|formato de respuesta|response shape|compatibil/i,
+    /arquitectura|architecture|scope|alcance|comportamiento|behavior|user.?visible|aceptaci[oó]n/i,
+  ];
+  const RESOLVABLE = [
+    /c[oó]mo se maneja|c[oó]mo funciona|c[oó]mo est[áa]|existe|hay |d[oó]nde est|qu[ée] herramienta|formato de|qu[ée] framework|qu[ée] versi[oó]n|config|tests?|documentaci[oó]n|endpoint existente|api existente/i,
+  ];
+  if (CRITICAL.some((p) => p.test(text))) return "DECISION_CRITICAL";
+  if (RESOLVABLE.some((p) => p.test(text))) return "RESOLVABLE";
+  return "NON_BLOCKING";
+}
+
+/** Convierte assumed/unknown del pre-flight en uncertainties clasificadas. */
+export function buildUncertainties(assumed = [], unknown = []) {
+  const seen = new Set();
+  const uncertainties = [];
+  const entries = [
+    ...(assumed || []).map((a) => ({ kind: "ASSUMED", text: String(a) })),
+    ...(unknown || []).map((u) => ({ kind: "UNKNOWN", text: String(u) })),
+  ];
+  for (const { kind, text } of entries) {
+    if (!text || seen.has(text)) continue;
+    seen.add(text);
+    uncertainties.push({
+      id: `U${uncertainties.length + 1}`,
+      question: text,
+      kind,
+      classification: classifyUncertainty(text),
+      status: "active",
+    });
+  }
+  return uncertainties;
+}
+
+const ASSUMPTION_IMPACT =
+  /elim|delet|borr|actualiz|update|schema|esquema|migraci|endpoint|api|arquitectur|estructura|m[oó]dulo|seguridad|auth|token|compatib|breaking|alcance|scope|destructiv|data.?loss|aceptaci[oó]n|criterios/i;
+
+/** Clasifica una asunción: DECISION_CRITICAL si toca impacto material. */
+export function classifyAssumption(statement = "") {
+  return ASSUMPTION_IMPACT.test(statement) ? "DECISION_CRITICAL" : "NON_BLOCKING";
+}
+
+/**
+ * Convierte asunciones textuales del análisis en objetos de estado.
+ */
+export function buildAssumptions(assumed = []) {
+  const seen = new Set();
+  const out = [];
+  for (const s of assumed || []) {
+    if (!s || typeof s !== "string") continue;
+    if (seen.has(s)) continue;
+    seen.add(s);
+    out.push({
+      id: `A${out.length + 1}`,
+      statement: s,
+      classification: classifyAssumption(s),
+      status: "active",
+    });
+  }
+  return out;
+}
+
+export function escalateAssumptions(state, taskText = "") {
+  const contract = state?.contract || {};
+  const escalated = [];
+  const assumptions = contract.assumptions || [];
+  let unknowns = contract.unknowns || [];
+  let changed = false;
+
+  for (const a of assumptions) {
+    if (a.status === "active" && a.classification === "NON_BLOCKING") {
+      const taskImpact = !!taskText && ASSUMPTION_IMPACT.test(taskText);
+      const genericAssumption = /funcionalidad|agregar nueva|nueva funcionalidad|add support|add.*support/i.test(a.statement);
+      const cls =
+        classifyAssumption(a.statement) === "DECISION_CRITICAL" ||
+        (taskImpact && genericAssumption)
+          ? "DECISION_CRITICAL"
+          : "NON_BLOCKING";
+      if (cls === "DECISION_CRITICAL") {
+        a.classification = cls;
+        a.status = "blocking";
+        const existing = unknowns.find((u) => u.status === "blocking" && !u.assumptionId);
+        if (existing) {
+          existing.assumptionId = a.id;
+        } else if (!unknowns.some((u) => u.assumptionId === a.id)) {
+          unknowns = [
+            ...unknowns,
+            {
+              id: `U${unknowns.length + 1}`,
+              kind: "ASSUMED",
+              question: `¿${a.statement}?`,
+              status: "blocking",
+              assumptionId: a.id,
+            },
+          ];
+        }
+        escalated.push(a);
+        changed = true;
+      }
+    }
+  }
+
+  if (changed) {
+    contract.assumptions = assumptions;
+    contract.unknowns = unknowns;
+    state.contract = contract;
+  }
+  return { escalated, changed };
+}

package/src/shared/container.js

@@ -0,0 +1,44 @@
+export function createContainer() {
+  const registry = new Map(); // name -> { factory, singleton, instance }
+
+  function register(name, factory, { singleton = true } = {}) {
+    if (typeof factory !== 'function') {
+      throw new TypeError(`Factory for "${name}" must be a function`);
+    }
+    registry.set(name, { factory, singleton, instance: undefined });
+  }
+
+  function resolve(name) {
+    const entry = registry.get(name);
+    if (!entry) {
+      throw new Error(`Dependency "${name}" is not registered`);
+    }
+    if (entry.singleton) {
+      if (entry.instance === undefined) {
+        entry.instance = entry.factory();
+      }
+      return entry.instance;
+    }
+    return entry.factory();
+  }
+
+  function has(name) {
+    return registry.has(name);
+  }
+
+  function unregister(name) {
+    if (!registry.has(name)) return false;
+    registry.delete(name);
+    return true;
+  }
+
+  function clear() {
+    registry.clear();
+  }
+
+  function list() {
+    return Array.from(registry.keys());
+  }
+
+  return { register, resolve, has, unregister, clear, list };
+}

package/src/shared/decision-types.js

@@ -0,0 +1,24 @@
+/**
+ * Decision Types — Standardized outcomes for WAM orchestration.
+ * 
+ * Every decision returns a consistent structure:
+ * {
+ *   action: string, // 'CONTINUE', 'BLOCK', 'REPLAN', 'VERIFY'
+ *   reason: string,
+ *   stateChange: object | null, // Optional state delta
+ *   evidenceNeeded: boolean,
+ *   critical: boolean
+ * }
+ */
+
+export function createDecision(action, reason, { stateChange = null, evidenceNeeded = false, critical = false } = {}) {
+  return { action, reason, stateChange, evidenceNeeded, critical };
+}
+
+export const ACTIONS = {
+  CONTINUE: "CONTINUE",
+  BLOCK: "BLOCK",
+  REPLAN: "REPLAN",
+  VERIFY: "VERIFY",
+  DONE: "DONE"
+};

package/src/shared/simple-test.js

@@ -0,0 +1,160 @@
+// Simple standalone test - doesn't import the full plugin
+// Just tests the core logic functions
+
+function assert(condition, message) {
+  if (!condition) throw new Error(message || 'Assertion failed');
+}
+
+console.log('=== Wait a Minute Simple Test Suite ===\n');
+
+let passed = 0;
+let failed = 0;
+
+// Test 1: isTrivial detects rename
+console.log('1. isTrivial detects rename');
+try {
+  // Mock the isTrivial logic
+  const lower = 'rename variable x to y'.toLowerCase();
+  const fastPatterns = [
+    /^\s*rename\s+/i,
+    /^\s*change\s+\w+/i,
+    /^\s*what(is|are)\s+/i,
+    /^\s*explain\s+/i,
+    /^\s*how\s+to\s+/i,
+    /^\s*list\s+/i,
+    /^\s*show\s+\w+/i,
+    /^\s*get\s+\w+/i,
+    /^\s*error\s+line/i,
+    /^\s*fix\s+this/i,
+  ];
+  let is trivial = false;
+  for (const pattern of fastPatterns) {
+    if (pattern.test(lower)) { isTrivial = true; break; }
+  }
+  assert(isTrivial === true, 'rename should be detected as trivial');
+  console.log('   ✓ rename detected as trivial');
+  passed++;
+} catch (e) {
+  console.log(`   ✗ Falló: ${e.message}`);
+  failed++;
+}
+
+// Test 2: requiresStrict detects migrate
+console.log('2. requiresStrict detects migrate');
+try {
+  const lower = 'migra PostgreSQL a la nube'.toLowerCase();
+  const strictPatterns = [
+    /migra|migrate/i,
+    /seguridad|security/i,
+    /arquitectura|architecture/i,
+    /alto impacto|high impact/i,
+    /producción|production/i,
+    /destructivo|destructive/i,
+  ];
+  const result = strictPatterns.some(p => p.test(lower));
+  assert(result === true, 'migrate should trigger STRICT');
+  console.log('   ✓ migrate detected as STRICT trigger');
+  passed++;
+} catch (e) {
+  console.log(`   ✗ Falló: ${e.message}`);
+  failed++;
+}
+
+// Test 3: analyze returns structure
+console.log('3. analyze returns structured result');
+try {
+  // Minimal test - just check the function exists and has expected shape
+  const analyze = async (opts) => {
+    const prompt = opts.prompt || '';
+    if (!prompt || typeof prompt !== 'string') {
+      return { intent: { classification: 'trivial', ambiguity: 'low', confidence: 100 }, project: { detected_stack: 'unknown', architecture: 'unknown', relevant_files: [] }, known: [], inferred: [], assumed: [], unknown: ['No hay prompt para analizar'], skills: { candidates: [], selected: [], rejected: [] }, risk: 'low', complexity: 'trivial', ambiguity: 'low', strategy: 'FAST', ready: true, advice: 'Sin prompt - sin análisis necesario' };
+    }
+    return { intent: { classification: 'normal', ambiguity: 'medium', confidence: 50 }, project: { detected_stack: 'unknown', architecture: 'unknown', relevant_files: [] }, known: [], inferred: [], assumed: [], unknown: [], skills: { candidates: [], selected: [], rejected: [] }, risk: 'medium', complexity: 'medium', ambiguity: 'medium', strategy: 'NORMAL', ready: false, advice: 'Requiere análisis' };
+  };
+  
+  const r = await analyze({ prompt: 'test prompt' });
+  assert(r.intent.classification === 'normal', 'Classification should be present');
+  assert(r.skills.selected instanceof Array, 'Skills selected should be array');
+  assert(r.risk === 'medium', 'Risk should be medium');
+  assert(r.strategy === 'NORMAL', 'Strategy should be NORMAL');
+  assert(r.ready === false, 'Ready should be false for non-trivial');
+  console.log('   ✓ analyze returns structured result');
+  passed++;
+} catch (e) {
+  console.log(`   ✗ Falló: ${e.message}`);
+  failed++;
+}
+
+// Test 4: isTrivial with various patterns
+console.log('4. isTrivial with various patterns');
+try {
+  const testPrompts = [
+    { prompt: 'list files', expected: true },
+    { prompt: 'show help', expected: true },
+    { prompt: 'explain this function', expected: true },
+    { prompt: 'change this variable', expected: true },
+    { prompt: 'agrega Redis', expected: false },  // ambiguous, not in fast patterns
+    { prompt: 'migra base de datos', expected: false }, // not trivial
+  ];
+  
+  const fastPatterns = [
+    /^\s*rename\s+/i,
+    /^\s*change\s+\w+/i,
+    /^\s*what(is|are)\s+/i,
+    /^\s*explain\s+/i,
+    /^\s*how\s+to\s+/i,
+    /^\s*list\s+/i,
+    /^\s*show\s+\w+/i,
+    /^\s*get\s+\w+/i,
+    /^\s*error\s+line/i,
+    /^\s*fix\s+this/i,
+  ];
+  
+  for (const {prompt, expected} of testPrompts) {
+    const lower = prompt.toLowerCase();
+    let is trivial = false;
+    for (const pattern of fastPatterns) {
+      if (pattern.test(lower)) { isTrivial = true; break; }
+    }
+    assert(isTrivial === expected, `${prompt}: expected ${expected}, got ${isTrivial}`);
+  }
+  console.log('   ✓ isTrivial works with multiple patterns');
+  passed++;
+} catch (e) {
+  console.log(`   ✗ Falló: ${e.message}`);
+  failed++;
+}
+
+// Test 5: requiresStrict with various patterns
+console.log('5. requiresStrict with various patterns');
+try {
+  const strictPatterns = [
+    /migra|migrate/i,
+    /seguridad|security/i,
+    /arquitectura|architecture/i,
+    /alto impacto|high impact/i,
+    /producción|production/i,
+    /destructivo|destructive/i,
+  ];
+  
+  const tests = [
+    { prompt: 'migra PostgreSQL', expected: true },
+    { prompt: 'seguridad del endpoint', expected: true },
+    { prompt: 'refactor module', expected: false },
+    { prompt: 'agrega cache', expected: false },
+  ];
+  
+  for (const {prompt, expected} of tests) {
+    const lower = prompt.toLowerCase();
+    const result = strictPatterns.some(p => p.test(lower));
+    assert(result === expected, `${prompt}: expected ${expected}, got ${result}`);
+  }
+  console.log('   ✓ requiresStrict works with multiple patterns');
+  passed++;
+} catch (e) {
+  console.log(`   ✗ Falló: ${e.message}`);
+  failed++;
+}
+
+console.log(`\n=== Results: ${passed} passed, ${failed} failed ===`);
+process.exitCode = failed > 0 ? 1 : 0;

package/src/shared/wam-events.js

@@ -0,0 +1,52 @@
+export const WAM_EVENTS = {
+  CONTEXT_LOADED: "CONTEXT_LOADED",
+  CONTEXT_INVALIDATED: "CONTEXT_INVALIDATED",
+  CLAIM_CREATED: "CLAIM_CREATED",
+  REQUIREMENT_CREATED: "REQUIREMENT_CREATED",
+  ACTION_STARTED: "ACTION_STARTED",
+  ACTION_COMPLETED: "ACTION_COMPLETED",
+  OBSERVATION_CREATED: "OBSERVATION_CREATED",
+  EVIDENCE_ADDED: "EVIDENCE_ADDED",
+  EVIDENCE_CONFLICT: "EVIDENCE_CONFLICT",
+  VERIFICATION_STARTED: "VERIFICATION_STARTED",
+  VERIFICATION_COMPLETED: "VERIFICATION_COMPLETED",
+  COMPLETION_BLOCKED: "COMPLETION_BLOCKED",
+  TASK_COMPLETED: "TASK_COMPLETED",
+};
+
+export function createEvent(type, data = {}) {
+  return {
+    id: `evt-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`,
+    type,
+    data,
+    timestamp: Date.now(),
+  };
+}
+
+export function logEvent(type, data, eventLog = []) {
+  const event = createEvent(type, data);
+  eventLog.push(event);
+  return event;
+}
+
+export function createDecisionTrace(decision) {
+  return {
+    id: `trace-${Date.now().toString(36)}`,
+    decision,
+    chain: [],
+    timestamp: Date.now(),
+  };
+}
+
+export function addToTrace(trace, step) {
+  return {
+    ...trace,
+    chain: [...trace.chain, { ...step, timestamp: Date.now() }],
+  };
+}
+
+export function formatDecisionTrace(trace) {
+  return trace.chain
+    .map((step, idx) => `${idx + 1}. [${step.type}] ${step.description}`)
+    .join("\n");
+}