@gobing-ai/superskill 0.2.5 → 0.2.7

package/dist/index.js

@@ -40829,7 +40829,7 @@ var init_dist5 = __esm(() => {
 });
 
 // ../../packages/core/src/targets.ts
-var TARGETS, TARGET_TO_RULESYNC, TARGET_SKILLS_RELDIR, TARGET_TO_AGENT_NAME;
+var TARGETS, TARGET_TO_RULESYNC, TARGET_TO_RULESYNC_HOOKS, TARGET_SKILLS_RELDIR, TARGET_TO_AGENT_NAME;
 var init_targets = __esm(() => {
   TARGETS = [
     "claude",
@@ -40848,6 +40848,12 @@ var init_targets = __esm(() => {
     "antigravity-cli": "codexcli",
     "antigravity-ide": "codexcli"
   };
+  TARGET_TO_RULESYNC_HOOKS = {
+    codex: "codexcli",
+    opencode: "opencode",
+    "antigravity-cli": "antigravity-cli",
+    "antigravity-ide": "antigravity-ide"
+  };
   TARGET_SKILLS_RELDIR = {
     codex: ".agents/skills",
     pi: ".agents/skills",
@@ -89666,9 +89672,10 @@ var init_dist9 = __esm(() => {
 // ../../packages/core/src/rulesync.ts
 import { homedir as homedir5 } from "os";
 async function runRulesync(targets, features, inputRoot, options2) {
+  const targetMap = options2.targetMap ?? TARGET_TO_RULESYNC;
   const mappedTargets = [];
   for (const target of targets) {
-    const rt = TARGET_TO_RULESYNC[target];
+    const rt = targetMap[target];
     if (rt)
       mappedTargets.push(rt);
   }
@@ -97508,6 +97515,271 @@ init_dist();
 import { homedir as homedir7 } from "os";
 import { join as join225 } from "path";
 
+// src/commands/hook-run.ts
+init_dist();
+import { spawnSync as spawnSync2 } from "child_process";
+
+// ../../plugins/cc/scripts/anti-hallucination/ah_guard.ts
+var SOURCE_PATTERNS = [
+  /\[Source:\s*[^\]]+\]/i,
+  /Source:\s*\[?[^\n]+\]?/i,
+  /Sources:\s*\n\s*-\s*\[?[^\n]+\]/i,
+  /https?:\/\/[^\s)]+/i,
+  /\*\*Source\*\*:\s*[^\n]+/i
+];
+var CONFIDENCE_PATTERNS = [
+  /Confidence:\s*(HIGH|MEDIUM|LOW)/i,
+  /\*\*Confidence\*\*:\s*(HIGH|MEDIUM|LOW)/i,
+  /### Confidence/i
+];
+var TOOL_PATTERNS = [
+  /ref_search_documentation/,
+  /ref_read_url/,
+  /searchCode/,
+  /WebSearch/,
+  /WebFetch/,
+  /mcp__ref__ref_search_documentation/,
+  /mcp__ref__ref_read_url/,
+  /mcp__grep__searchCode/
+];
+var RED_FLAG_PATTERNS = [
+  /I (?:think|believe|recall) (?:that|the)?/gi,
+  /(?:It|This) (?:should|might|may|could)/gi,
+  /Probably|Likely|Possibly/gi,
+  /(?:As far as|If I) (?:know|recall)/gi
+];
+function buildStopOutput(result) {
+  if (result.ok) {
+    return JSON.stringify({
+      hookSpecificOutput: { hookEventName: "Stop", additionalContext: result.reason }
+    });
+  }
+  return JSON.stringify({
+    decision: "block",
+    reason: result.reason,
+    hookSpecificOutput: { hookEventName: "Stop" }
+  });
+}
+function extractLastAssistantMessage(context3) {
+  const messages2 = context3.messages ?? [];
+  for (let i2 = messages2.length - 1;i2 >= 0; i2--) {
+    const message = messages2[i2];
+    if (message?.role === "assistant") {
+      const content = message.content;
+      if (Array.isArray(content)) {
+        const textParts = [];
+        for (const part of content) {
+          if (part.type === "text" && part.text) {
+            textParts.push(part.text);
+          }
+        }
+        return textParts.join(`
+`);
+      }
+      return String(content);
+    }
+  }
+  const lastMsg = context3.last_message;
+  if (lastMsg) {
+    return String(lastMsg);
+  }
+  return;
+}
+function hasSourceCitations(text3) {
+  if (!text3)
+    return false;
+  for (const pattern of SOURCE_PATTERNS) {
+    if (pattern.test(text3)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasConfidenceLevel(text3) {
+  if (!text3)
+    return false;
+  for (const pattern of CONFIDENCE_PATTERNS) {
+    if (pattern.test(text3)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasToolUsageEvidence(text3) {
+  if (!text3)
+    return false;
+  for (const pattern of TOOL_PATTERNS) {
+    if (pattern.test(text3)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasRedFlags(text3) {
+  if (!text3)
+    return [];
+  const foundFlags = [];
+  for (const pattern of RED_FLAG_PATTERNS) {
+    const matches = text3.match(pattern);
+    if (matches) {
+      foundFlags.push(...matches);
+    }
+  }
+  return foundFlags;
+}
+function requiresExternalVerification(text3) {
+  if (!text3)
+    return false;
+  const verificationKeywords = [
+    "api",
+    "library",
+    "framework",
+    "method",
+    "function",
+    "version",
+    "documentation",
+    "official",
+    /recent\s+(?:change|update|release)/i,
+    /\d+\.\d+(?:\.\d+)?/,
+    /https?:\/\//
+  ];
+  const textLower = text3.toLowerCase();
+  for (const keyword of verificationKeywords) {
+    if (typeof keyword === "string") {
+      if (textLower.includes(keyword)) {
+        return true;
+      }
+    } else if (keyword.test(textLower)) {
+      return true;
+    }
+  }
+  return false;
+}
+function verifyAntiHallucinationProtocol(text3) {
+  if (!text3 || text3.trim().length < 50) {
+    return { ok: true, reason: "Task is complete" };
+  }
+  const needsVerification = requiresExternalVerification(text3);
+  if (!needsVerification) {
+    return { ok: true, reason: "Task is complete (internal discussion)" };
+  }
+  const hasSources = hasSourceCitations(text3);
+  const hasConfidence = hasConfidenceLevel(text3);
+  const hasTools = hasToolUsageEvidence(text3);
+  const redFlags = hasRedFlags(text3);
+  const issues = [];
+  if (!hasSources) {
+    issues.push("source citations for API/library claims");
+  }
+  if (!hasConfidence) {
+    issues.push("confidence level (HIGH/MEDIUM/LOW)");
+  }
+  if (redFlags.length > 0 && !hasTools) {
+    const uniqueFlags = Array.from(new Set(redFlags)).slice(0, 3);
+    issues.push(`uncertainty phrases detected: ${uniqueFlags.join(", ")}`);
+  }
+  if (issues.length > 0) {
+    const reason = `Add verification for: ${issues.join(", ")}`;
+    return { ok: false, reason, issues };
+  }
+  return { ok: true, reason: "Task is complete" };
+}
+if (false) {}
+
+// src/commands/hook-run.ts
+function preToolUseDecision(decision, reason) {
+  const out = {
+    hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: decision }
+  };
+  if (reason !== undefined)
+    out.systemMessage = reason;
+  return { output: JSON.stringify(out), exitCode: 0 };
+}
+function resolveSpurTaskOwnership(filePath, cwd5) {
+  const res = spawnSync2("spur", ["task", "resolve", filePath, "--strict", "--json"], {
+    cwd: cwd5,
+    encoding: "utf-8",
+    timeout: 8000
+  });
+  if (res.error || typeof res.status !== "number")
+    return "unknown";
+  return res.status === 0 ? "owned" : "unowned";
+}
+function runSpTaskWriteGuard(env, stdinText, resolveTaskOwnership = resolveSpurTaskOwnership) {
+  if (env.SPUR_WRITE_GUARD === "off")
+    return preToolUseDecision("allow");
+  let payload;
+  try {
+    payload = JSON.parse(stdinText);
+  } catch {
+    return preToolUseDecision("allow");
+  }
+  const toolName = payload.tool_name ?? "";
+  if (toolName !== "Write" && toolName !== "Edit")
+    return preToolUseDecision("allow");
+  const filePath = payload.tool_input?.file_path ?? "";
+  if (filePath === "")
+    return preToolUseDecision("allow");
+  const ownership = resolveTaskOwnership(filePath, env.CLAUDE_PROJECT_DIR ?? process.cwd());
+  if (ownership === "owned") {
+    return preToolUseDecision("deny", `${filePath} is a task file owned by the spur corpus. Edit it through the spur CLI ` + "(e.g. `spur task update <wbs> --section <name> --from-file <file>`), not a raw " + "Write/Edit. Set SPUR_WRITE_GUARD=off to bypass.");
+  }
+  return preToolUseDecision("allow");
+}
+var spTaskWriteGuard = {
+  run: runSpTaskWriteGuard
+};
+var ccAntiHallucination = {
+  run(env) {
+    const argumentsJson = env.ARGUMENTS ?? "{}";
+    const allowStop = (feedback, ok) => ({
+      output: buildStopOutput({ ok, reason: feedback }),
+      exitCode: ok ? 0 : 1
+    });
+    let context3;
+    try {
+      context3 = JSON.parse(argumentsJson);
+    } catch {
+      return allowStop("Task is complete (invalid context ignored)", true);
+    }
+    const content = extractLastAssistantMessage(context3);
+    if (content === undefined)
+      return allowStop("No content to verify", true);
+    const result = verifyAntiHallucinationProtocol(content);
+    return allowStop(result.reason, result.ok);
+  }
+};
+var HOOK_RUNNERS = {
+  "sp/task-write-guard": spTaskWriteGuard,
+  "cc/anti-hallucination": ccAntiHallucination
+};
+function hookRun(plugin, hookId, env, stdinText) {
+  const runner = HOOK_RUNNERS[`${plugin}/${hookId}`];
+  if (!runner) {
+    echoError(`Error: unknown hook '${plugin} ${hookId}'. Known hooks: ${Object.keys(HOOK_RUNNERS).join(", ")}`);
+    return 2;
+  }
+  const result = runner.run(env, stdinText);
+  echo(result.output);
+  return result.exitCode;
+}
+function registerHookRun(cmd, readInput) {
+  cmd.command("run <plugin> <hook-id>").description("Run a registered plugin hook runner (the runtime command installed hook configs call)").action((plugin, hookId) => {
+    let stdinText = "";
+    if (readInput) {
+      stdinText = readInput();
+    } else {
+      try {
+        stdinText = __require("fs").readFileSync(0, "utf-8");
+      } catch {
+        stdinText = "";
+      }
+    }
+    const code = hookRun(plugin, hookId, process.env, stdinText);
+    process.exit(code);
+  });
+}
+
 // src/commands/install.ts
 init_src();
 init_dist();
@@ -97687,7 +97959,7 @@ async function executeInstall(plugin, targets2, options2, dependencies = {}) {
     const targetInputRoot = prepareTargetRulesyncInput(outputDir, target, plugin);
     targetInputRoots.set(target, targetInputRoot);
   }
-  const rulesyncFeatures = ["skills", "hooks", ...mapResult.mcp ? ["mcp"] : []];
+  const rulesyncFeatures = ["skills", ...mapResult.mcp ? ["mcp"] : []];
   const rulesyncTargets = targets2.filter((t) => t !== "claude" && t !== "hermes" && t !== "omp");
   if (targets2.includes("omp") && !targets2.includes("pi")) {
     if (!targetInputRoots.has("pi")) {
@@ -97726,6 +97998,20 @@ async function executeInstall(plugin, targets2, options2, dependencies = {}) {
       resultCounts.subagentsCount += result.subagentsCount;
       resultCounts.hooksCount += result.hooksCount;
     }
+    if (mapResult.hooks) {
+      for (const target of rulesyncTargets) {
+        if (!TARGET_TO_RULESYNC_HOOKS[target])
+          continue;
+        const hookResult = await runRulesyncImpl([target], ["hooks"], targetInputRoots.get(target) ?? outputDir, {
+          global: options2.global,
+          dryRun: options2.dryRun,
+          verbose: options2.verbose,
+          outputRoot: options2.outputRoot,
+          targetMap: TARGET_TO_RULESYNC_HOOKS
+        });
+        resultCounts.hooksCount += hookResult.hooksCount;
+      }
+    }
     if (options2.verbose) {
       echo(`  Skills written: ${resultCounts.skillsCount}, Commands: ${resultCounts.commandsCount}, Subagents: ${resultCounts.subagentsCount}, Hooks: ${resultCounts.hooksCount}`);
     }
@@ -98005,6 +98291,7 @@ function registerHook(program2) {
   addTargetOption(cmd.command("emit <name>").description("Emit a hook definition to a single target agent (thin wrapper over the install hook path)")).option("--global", "Install to user-level global directory (default)", true).option("--dry-run", "Preview without writing files", false).action(async (name, opts) => {
     await runOperation(() => hookEmit({ name, ...opts }));
   });
+  registerHookRun(cmd);
 }
 
 // src/commands/magent.ts

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/superskill",
-    "version": "0.2.5",
+    "version": "0.2.7",
     "description": "A manager for multi-agent skill, slash command, subagent, hook, MCP and etc.",
     "keywords": [
         "cli",