ostacky 0.8.7 → 0.9.0

package/assets/plugins/security.ts

@@ -0,0 +1,118 @@
+/**
+ * security.ts — mirror de src/security.ts para plugin (self-contained, solo Sensitive guard)
+ * Generado desde src/security.ts — NO EDITAR. Ejecutá `bun run scripts/sync-controller-core.ts`.
+ */
+
+// ─── Sensitive guard — source-of-truth (hardening-v2 D1) ───────────────
+
+export const SENSITIVE_DEFAULT: string[] = [
+  "**/.env*",
+  "**/.secrets/**",
+  "**/*.pem",
+  "**/*.key",
+  "**/.aws/**",
+  "**/.ssh/**",
+  "**/credentials.json",
+  "**/.npmrc",
+];
+
+/**
+ * Regex que detecta acceso sensible en comandos bash.
+ * Cubre .env, .secrets, .pem, .key, .aws, .ssh, credentials.json, .npmrc
+ * Normalizar antes (strip quotes/backslashes) y testear con `BASH_SENSITIVE_RE.test(normalized)`.
+ */
+export const BASH_SENSITIVE_RE =
+  /(?:^|[^a-zA-Z0-9_.-])(\.env(\b|[_.-])|\.secrets\b|\.pem\b|\.key\b|credentials\.json|\.aws\b|\.ssh\b|\.npmrc\b)/i;
+
+/**
+ * Returns true if filePath is considered sensitive given patterns.
+ * - Allowlist: .env.example / .env.template / .env.sample nunca son sensibles.
+ * - Normaliza backslashes a "/" para Windows.
+ * - patterns: array de globs como SENSITIVE_DEFAULT; si no se pasa usa SENSITIVE_DEFAULT.
+ */
+export function isSensitive(filePath: string, patterns: string[] = SENSITIVE_DEFAULT): boolean {
+  if (!filePath) return false;
+  const normalized = filePath.replace(/\\/g, "/");
+  const lower = normalized.toLowerCase();
+  if (
+    lower.endsWith(".env.example") ||
+    lower.endsWith(".env.template") ||
+    lower.endsWith(".env.sample")
+  )
+    return false;
+  const base = lower.split("/").pop() || "";
+  for (const pat of patterns) {
+    if (pat.includes(".env") && base.startsWith(".env")) return true;
+    if (pat.includes(".secrets") && lower.includes(".secrets")) return true;
+    if (pat.includes("*.pem") && lower.endsWith(".pem")) return true;
+    if (pat.includes("*.key") && lower.endsWith(".key")) return true;
+    if (pat.includes(".aws") && lower.includes(".aws")) return true;
+    if (pat.includes(".ssh") && lower.includes(".ssh")) return true;
+    if (pat.includes("credentials.json") && lower.endsWith("credentials.json")) return true;
+    if (pat.includes(".npmrc") && lower.endsWith(".npmrc")) return true;
+  }
+  // fallback genérico por extensión
+  if (/\.(pem|key)$/i.test(normalized)) return true;
+  if (base.startsWith(".env")) return true;
+  return false;
+}
+
+/**
+ * Extrae paths candidatos de un comando bash para chequear sensibilidad.
+ * Tokeniza por separadores shell `| ; && || > >> <` y respeta quotes.
+ * Normaliza quitando quotes y backslashes para detectar obfuscaciones como .e""nv.
+ */
+export function extractPathsFromBash(cmd: string): string[] {
+  if (!cmd) return [];
+  // Normalizar && y || a ; para split único
+  const normalized = cmd.replace(/&&/g, ";").replace(/\|\|/g, ";");
+  // Split por separadores shell
+  const segments = normalized.split(/[|;><\n]+/);
+  const paths: string[] = [];
+  for (const seg of segments) {
+    const trimmed = seg.trim();
+    if (!trimmed) continue;
+    // Tokeniza respetando quotes — captura tokens entre quotes o sin espacios
+    const tokens = trimmed.match(/(?:[^\s"'`\\]+|"[^"]*"|'[^']*'|`[^`]*`)+/g) || [];
+    for (let token of tokens) {
+      // Normalización anti-obfuscación: quitar quotes y backslashes
+      const stripped = token.replace(/["'`]/g, "").replace(/\\/g, "");
+      if (!stripped) continue;
+      // Filtrar comandos comunes y flags
+      if (["cat", "grep", "ls", "echo", "awk", "sed", "cut", "head", "tail", "wc", "find", "xargs", "bash", "sh", "zsh", "env", "printenv", "node", "bun", "npm", "npx", "ls"].includes(stripped)) continue;
+      if (stripped.startsWith("-")) continue;
+      // Heurística de path: contiene / o . o es .env* o sensible
+      const lower = stripped.toLowerCase();
+      if (
+        stripped.includes("/") ||
+        stripped.includes(".") ||
+        lower.startsWith(".env") ||
+        lower.includes(".secrets") ||
+        lower.endsWith(".pem") ||
+        lower.endsWith(".key") ||
+        lower.includes(".aws") ||
+        lower.includes(".ssh") ||
+        lower.endsWith("credentials.json") ||
+        lower.endsWith(".npmrc")
+      ) {
+        // Limpiar trailing chars como : , )
+        const cleaned = stripped.replace(/[,:;)\]]+$/, "");
+        if (cleaned) paths.push(cleaned);
+      } else if (stripped === ".env") {
+        paths.push(stripped);
+      }
+    }
+  }
+  // También buscar paths con regex global como fallback
+  // (detecta .env en strings complejos)
+  return [...new Set(paths)];
+}
+
+/**
+ * Lee patrones sensibles desde env OSTACKY_SENSITIVE_PATTERNS o usa default.
+ */
+export function getSensitivePatterns(): string[] {
+  const raw = process.env.OSTACKY_SENSITIVE_PATTERNS;
+  if (!raw) return SENSITIVE_DEFAULT;
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}

package/assets/plugins/tiered.ts

@@ -0,0 +1,46 @@
+/**
+ * tiered.ts — mirror de src/tiered.ts para plugin (self-contained)
+ * Generado desde src/tiered.ts — NO EDITAR. Ejecutá `bun run scripts/sync-controller-core.ts`.
+ */
+
+/**
+ * Tiered helpers — single source of truth for trivial detection y niveles.
+ *
+ * Ambos plugins (ostacky-plugin.ts y engram.ts) importan de acá.
+ * No duplicar regex. Cache-friendly: isTrivial no muta system[0], solo decide hint.
+ * LEVEL_THRESHOLDS es la única definición de niveles (D6).
+ */
+
+export const LEVEL_THRESHOLDS = {
+  "0": { maxFiles: 1, maxLines: 15, hasAPI: false, desc: "1 archivo, sin API, <15 líneas" },
+  "0+1": { maxFiles: 2, maxLines: 30, hasAPI: false, desc: "1-2 archivos, sin API, <30 líneas" },
+  "1+": { maxFiles: Infinity, maxLines: Infinity, hasAPI: true, desc: "API, deps, >30 líneas, cross-module" },
+} as const;
+
+export function classifyLevel({ fileCount, estLines, hasAPI }: { fileCount: number; estLines: number; hasAPI: boolean }): "0" | "0+1" | "1+" {
+  if (hasAPI || estLines > 30 || fileCount > 2) return "1+";
+  if (estLines > 15 || fileCount > 1) return "0+1";
+  return "0";
+}
+
+export function isTrivial(msg: string, state: string): boolean {
+  if (!msg || state !== "DONE") return false
+  if (msg.trim().length >= 30) return false
+  if (!/^(hola|hey|gracias|buenas|hi|hello)\b/i.test(msg.trim())) return false
+  if (/(necesito|quiero|agregá|fix|bug|feature|auth|spec|implementar)/i.test(msg)) return false
+  return true
+}
+
+export function getControllerState(directory: string): string {
+  try {
+    const { readFileSync } = require("node:fs") as typeof import("node:fs")
+    const { join } = require("node:path") as typeof import("node:path")
+    const statePath =
+      process.env.OSTACKY_STATE_PATH || join(directory, ".opencode", "ostacky-state.json")
+    const raw = readFileSync(statePath, "utf-8")
+    const j = JSON.parse(raw)
+    return j.state ?? "DONE"
+  } catch {
+    return "DONE"
+  }
+}

package/assets/skills/dispatching-parallel-agents/SKILL.md

@@ -129,6 +129,7 @@ Return: Summary of what you found and what you fixed.
 **Need full context:** Understanding requires seeing entire system
 **Exploratory debugging:** You don't know what's broken yet
 **Shared state:** Agents would interfere (editing same files, using same resources)
+**Ostacky execution:** If `execution-mode-evaluation` already produced `fileClusters/sharedFiles` — **DO NOT use this skill**; use `subagent-driven-development` dispatch por clusters (respeta `sharedFiles` y `sequentialDeps` del Controller, evita pisar mismo archivo desde 2 agentes).
 
 ## Real Example from Session
 

package/assets/skills/openspec-explore/SKILL.md

@@ -39,10 +39,11 @@ Depending on what the user brings, you might:
 - Find analogies
 
 **Investigate the codebase**
-- Map existing architecture relevant to the discussion
+- Map existing architecture relevant to the discussion (ground with `codegraph_codegraph_explore` + `engram_mem_search` if pre-1+ or without active change)
 - Find integration points
 - Identify patterns already in use
 - Surface hidden complexity
+- **Level note:** Si necesitás ruteo por nivel Ostacky (0/0+1/1+) usa `brainstorming` en vez de este stance; este skill asume ya estás en flujo OpenSpec (1+).
 
 **Compare options**
 - Brainstorm multiple approaches

package/assets/skills/openspec-propose/SKILL.md

@@ -26,7 +26,9 @@ When ready to implement, run /opsx-apply
 
 **Steps**
 
-1. **Check Engram for similar changes** — `engram_mem_search` with keywords from the user's description. If a similar change was proposed or implemented before, surface it to the user. They may want to extend the existing work instead of starting fresh.
+0. **Ground with CodeGraph + Engram (SHALL — Ostacky)** — Antes de `openspec new`, verifica `getDiscoverySnapshot(query)` + `getEngramDedup`. Si miss → `codegraph_codegraph_explore` + `engram_mem_search` + `putDiscoverySnapshot`. Cita símbolos existentes en `proposal/design`; sin esto el `design.md` puede alucinar API inexistente y dispara `WARN:codegraphBypass` en `doctor`.
+
+1. **Check Engram for similar changes** — `engram_mem_search` con keywords del *paso 0* (reusar si ya fue hit; no duplicar `mem_search` mismo `requestId`). Si hay change similar previo, surfacealo. Pueden extender trabajo existente en vez de empezar de cero.
 
 2. **If no clear input provided, ask what they want to build**
 

package/assets/skills/tdd/SKILL.md

@@ -28,6 +28,8 @@ Write the test first. Watch it fail. Write minimal code to pass.
 
 Thinking "skip TDD just this once"? Stop. That's rationalization.
 
+> **Ostacky ground (SHALL):** Antes de RED, verifica `getDiscoverySnapshot(query)` + `getEngramDedup`. Si hit → reusar símbolos/decisiones; si miss → `codegraph_codegraph_explore` + `engram_mem_search` + `putDiscoverySnapshot`. Evita testear API inexistente y respeta `discovery-cache (único)` de `ostacky.md §1`. Ver `execution-mode-evaluation` para cache TTL.
+
 ## The Iron Law
 
 ```