@brawnen/agent-harness-cli 0.1.0 → 0.1.1

package/src/lib/hook-io/gemini.js

@@ -0,0 +1,130 @@
+import { firstDefined, firstString } from "./shared.js";
+
+export function buildGeminiHookOutput(decision) {
+  if (decision.status === "block") {
+    return {
+      decision: "deny",
+      reason: decision.reason
+    };
+  }
+
+  if (!decision.additionalContext) {
+    return {};
+  }
+
+  return {
+    hookSpecificOutput: {
+      additionalContext: decision.additionalContext
+    }
+  };
+}
+
+export function resolveGeminiCompletionMessage(payload) {
+  return firstString([
+    payload?.prompt_response,
+    payload?.response,
+    payload?.last_assistant_message
+  ]) ?? "";
+}
+
+export function resolveGeminiToolName(payload) {
+  return firstString([
+    payload?.tool_name,
+    payload?.toolName,
+    payload?.tool?.name,
+    payload?.toolUse?.name,
+    payload?.name
+  ]);
+}
+
+export function resolveGeminiToolCommand(payload) {
+  return firstString([
+    payload?.tool_input?.command,
+    payload?.toolInput?.command,
+    payload?.input?.command,
+    payload?.arguments?.command,
+    payload?.tool_use?.input?.command,
+    payload?.toolUse?.input?.command,
+    payload?.command
+  ]) ?? "";
+}
+
+export function resolveGeminiToolPath(payload) {
+  return firstString([
+    payload?.tool_input?.file_path,
+    payload?.tool_input?.path,
+    payload?.toolInput?.file_path,
+    payload?.toolInput?.path,
+    payload?.input?.file_path,
+    payload?.input?.path,
+    payload?.arguments?.file_path,
+    payload?.arguments?.path,
+    payload?.tool_use?.input?.file_path,
+    payload?.tool_use?.input?.path,
+    payload?.toolUse?.input?.file_path,
+    payload?.toolUse?.input?.path
+  ]);
+}
+
+export function resolveGeminiToolExitCode(payload) {
+  const value = firstDefined([
+    payload?.exit_code,
+    payload?.exitCode,
+    payload?.result?.exit_code,
+    payload?.result?.exitCode,
+    payload?.tool_response?.exit_code,
+    payload?.tool_response?.exitCode,
+    payload?.toolResponse?.exit_code,
+    payload?.toolResponse?.exitCode,
+    payload?.status
+  ]);
+
+  if (typeof value === "number") {
+    return value;
+  }
+
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+
+  return null;
+}
+
+export function resolveGeminiToolOutput(payload) {
+  const directOutput = firstString([
+    payload?.tool_response?.output,
+    payload?.tool_response?.stdout,
+    payload?.toolResponse?.output,
+    payload?.toolResponse?.stdout,
+    payload?.stdout,
+    payload?.stderr,
+    payload?.result?.output,
+    payload?.result?.stdout,
+    payload?.output
+  ]);
+
+  if (directOutput) {
+    return directOutput;
+  }
+
+  const displayOutput = firstString([
+    payload?.tool_response?.returnDisplay,
+    payload?.toolResponse?.returnDisplay
+  ]);
+
+  if (displayOutput) {
+    return displayOutput;
+  }
+
+  const responsePayload = firstDefined([
+    payload?.tool_response,
+    payload?.toolResponse
+  ]);
+
+  if (!responsePayload || typeof responsePayload === "string") {
+    return responsePayload ?? "";
+  }
+
+  return JSON.stringify(responsePayload);
+}

package/src/lib/hook-io/shared.js

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+
+import { resolveHarnessProjectRoot } from "../runtime-paths.js";
+
+export function readHookPayload() {
+  const raw = fs.readFileSync(0, "utf8").trim();
+  if (!raw) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error("hook stdin 不是合法 JSON");
+  }
+}
+
+export function resolvePayloadCwd(payload) {
+  return resolveHarnessProjectRoot(payload?.cwd || process.cwd());
+}
+
+export function resolvePayloadPrompt(payload) {
+  if (typeof payload?.prompt === "string") {
+    return payload.prompt;
+  }
+  if (typeof payload?.input === "string") {
+    return payload.input;
+  }
+  return "";
+}
+
+export function firstDefined(values) {
+  for (const value of values) {
+    if (value !== undefined && value !== null) {
+      return value;
+    }
+  }
+  return null;
+}
+
+export function firstString(values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return null;
+}
+
+export function writeHookOutput(result) {
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}

package/src/lib/runtime-paths.js

@@ -4,6 +4,13 @@ import path from "node:path";
 export const DEFAULT_RUNTIME_DIR = ".harness";
 export const LEGACY_RUNTIME_DIR = "harness";
 
+const STRONG_PROJECT_ROOT_MARKERS = [
+  "harness.yaml",
+  ".codex/hooks.json",
+  ".claude/settings.json",
+  ".gemini/settings.json"
+];
+
 export function resolveRuntimeDirName(cwd, options = {}) {
   const preferExisting = options.preferExisting !== false;
   if (preferExisting) {
@@ -17,6 +24,26 @@ export function resolveRuntimeDirName(cwd, options = {}) {
   return DEFAULT_RUNTIME_DIR;
 }
 
+export function resolveHarnessProjectRoot(cwd) {
+  const fallback = path.resolve(cwd || process.cwd());
+  let current = fallback;
+  let bestCandidate = null;
+
+  while (true) {
+    const score = getProjectRootScore(current);
+    if (score > 0 && (!bestCandidate || score > bestCandidate.score)) {
+      bestCandidate = { path: current, score };
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return bestCandidate?.path ?? fallback;
+    }
+
+    current = parent;
+  }
+}
+
 export function runtimePath(cwd, ...segments) {
   return path.join(cwd, resolveRuntimeDirName(cwd), ...segments);
 }
@@ -44,3 +71,15 @@ export function runtimeRelativeCandidates(...segments) {
 export function hasRuntimeSetup(cwd) {
   return runtimeRelativeCandidates().some((relativePath) => fs.existsSync(path.join(cwd, relativePath)));
 }
+
+function getProjectRootScore(cwd) {
+  if (STRONG_PROJECT_ROOT_MARKERS.some((relativePath) => fs.existsSync(path.join(cwd, relativePath)))) {
+    return 2;
+  }
+
+  if (fs.existsSync(path.join(cwd, DEFAULT_RUNTIME_DIR)) || fs.existsSync(path.join(cwd, LEGACY_RUNTIME_DIR))) {
+    return 1;
+  }
+
+  return 0;
+}

package/src/lib/task-core.js

@@ -25,6 +25,12 @@ const CONTINUE_KEYWORDS = [
   "follow-up"
 ];
 
+const AFFIRMATIVE_SHORT_REPLIES = [
+  "ok", "okay", "好", "好的", "嗯", "对", "是的", "可以",
+  "行", "没问题", "同意", "确认", "yes", "yep", "sure", "lgtm",
+  "先这样", "就这样", "开始吧", "搞起", "go"
+];
+
 const NEW_TASK_KEYWORDS = [
   "新任务",
   "另一个问题",
@@ -245,7 +251,7 @@ export function autoIntakePrompt(cwd, prompt) {
     return {
       action: "continue",
       task: activeTask,
-      additionalContext: buildCurrentTaskContext(activeTask),
+      additionalContext: "",
       decision
     };
   }
@@ -389,6 +395,15 @@ function classifyPromptAgainstTask(prompt, activeTask) {
     });
   }
 
+  if (isAffirmativeShortReply(normalizedPrompt)) {
+    return buildDecision("continue", {
+      reasonCode: "affirmative_short_reply",
+      reason: "输入为确认性短回复，视为延续当前任务。",
+      matchedSignals: ["affirmative_short_reply"],
+      confidence: "medium"
+    });
+  }
+
   const ambiguous = isAmbiguousPrompt(prompt);
   if (ambiguous) {
     const matchedHighRiskKeyword = findMatchedKeyword(normalizedPrompt, HIGH_RISK_KEYWORDS);
@@ -397,8 +412,8 @@ function classifyPromptAgainstTask(prompt, activeTask) {
       block: highRisk,
       reasonCode: highRisk ? "ambiguous_high_risk_prompt" : "ambiguous_prompt",
       reason: highRisk
-        ? "当前输入任务归属不明且包含高风险信号。先澄清是在延续旧任务还是新任务，再继续执行。"
-        : "当前输入无法可靠判断是在延续旧任务还是新任务。先向用户澄清任务归属，再继续执行。",
+        ? "输入任务归属不明且含高风险信号，请先澄清。"
+        : "输入归属不明，请先澄清是延续当前任务还是新任务。",
       matchedSignals: highRisk
         ? [`high_risk_keyword:${matchedHighRiskKeyword}`, "ambiguous_prompt"]
         : ["ambiguous_prompt"],
@@ -428,6 +443,11 @@ function isAmbiguousPrompt(prompt) {
   return ["看一下这个", "有个问题", "帮我处理一下", "处理下", "看看这个"].some((text) => normalized.includes(text));
 }
 
+function isAffirmativeShortReply(normalizedPrompt) {
+  const trimmed = normalizedPrompt.trim();
+  return AFFIRMATIVE_SHORT_REPLIES.some((reply) => trimmed === reply);
+}
+
 function inferIntent(input) {
   const normalized = input.toLowerCase();
   if (EXPLORE_KEYWORDS.some((keyword) => normalized.includes(keyword))) {