ework-aio 0.2.9 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ework-aio",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "description": "All-in-one installer for ework (issue tracker) + ework-daemon (AI bridge) + opencode-ework (plugin). One command: npm i -g ework-aio && ework-aio install.",
   "type": "module",
   "license": "MIT",

package/scripts/e2e-browser.sh

@@ -67,6 +67,7 @@ info() { printf '%s…%s %s\n' "$c_ylw" "$c_rst" "$*" >&2; }
 WORK_PORT="${WORK_PORT:-14002}"
 DAEMON_PORT="${DAEMON_PORT:-14101}"
 FAKE_LLM_PORT="${FAKE_LLM_PORT:-8400}"
+BOT_LOGIN="${BOT_LOGIN:-e2e-bot}"
 NPM_TAG="${NPM_TAG:-latest}"
 DATA_DIR=/tmp/aio-browser
 
@@ -232,6 +233,13 @@ OPENCODE_DB="$HOME/.local/share/opencode/opencode.db"
 sql_query() {
   bun -e "const db=require('bun:sqlite');const d=new db.Database('$1',{readonly:true,create:false});try{process.stdout.write(JSON.stringify(d.prepare(\`$2\`).all()))}catch(e){process.stdout.write('')}" 2>/dev/null
 }
+# The smoke test in the previous step already wrote a session row. To avoid
+# grabbing that one, capture its ID first and wait for a NEW session ID to
+# appear (the daemon spawns its own opencode against a different --dir, so
+# its session ID will differ).
+PREV_SESSION_ID=$(sql_query "$OPENCODE_DB" "SELECT id FROM session ORDER BY time_updated DESC LIMIT 1;" \
+  | jq -r '.[0].id // empty' 2>/dev/null || echo "")
+echo "  smoke test session: ${PREV_SESSION_ID:-(none yet)}"
 SESSION_ID=""
 # 180s window: opencode spawn + fake-LLM roundtrip + write to DB. The
 # daemon's poller picks up the issue within ~30s, then opencode takes
@@ -239,7 +247,7 @@ SESSION_ID=""
 for i in $(seq 1 180); do
   ROWS=$(sql_query "$OPENCODE_DB" "SELECT id FROM session ORDER BY time_updated DESC LIMIT 1;")
   SESSION_ID=$(echo "$ROWS" | jq -r '.[0].id // empty' 2>/dev/null || echo "")
-  if [[ -n "$SESSION_ID" ]]; then
+  if [[ -n "$SESSION_ID" && "$SESSION_ID" != "$PREV_SESSION_ID" ]]; then
     pass "session created: $SESSION_ID (after ${i}s)"
     break
   fi
@@ -249,7 +257,7 @@ for i in $(seq 1 180); do
     tail -40 "$DATA_DIR/run/daemon.log" 2>/dev/null || echo "(no daemon.log)"
     echo "--- fake-llm log (last 10) ---"
     tail -10 /tmp/fake-llm.log
-    fail "opencode did not write a session";
+    fail "daemon's opencode did not write a new session (last seen: $SESSION_ID)";
   }
 done
 
@@ -292,6 +300,35 @@ echo "$SESSION_PAGE_HTML" | grep -q "E2E fake-LLM" \
   || fail "session page does not contain fake-LLM reply text"
 pass "session page renders fake-LLM reply content"
 
+info "check whether the bot actually replied on the issue (auto-reply)"
+# ework-web exposes the issue comments via /api/v1/repos/<o>/<r>/issues/<n>/comments
+# (Gitea-compatible). Two distinct kinds of bot-authored comments exist:
+#   1. [system] "picked up this issue" — posted by the daemon on session start
+#      (NOT an LLM reply; doesn't count).
+#   2. [bot] actual reply — posted by the LLM via the opencode-ework `reply`
+#      tool. This is the auto-reply behaviour we're validating.
+COMMENTS_JSON=$(curl -sS -H "Cookie: $AUTH_COOKIE" \
+  "http://127.0.0.1:$WORK_PORT/api/v1/repos/e2e/browser-test/issues/1/comments")
+COMMENTS_COUNT=$(echo "$COMMENTS_JSON" | jq 'length' 2>/dev/null || echo 0)
+BOT_COMMENTS_COUNT=$(echo "$COMMENTS_JSON" \
+  | jq --arg bot "$BOT_LOGIN" '[.[] | select(.user.login == $bot)] | length' 2>/dev/null || echo 0)
+LLM_REPLIES=$(echo "$COMMENTS_JSON" \
+  | jq --arg bot "$BOT_LOGIN" \
+       '[.[] | select(.user.login == $bot and (.body | startswith("[bot]")))] | length' 2>/dev/null || echo 0)
+echo "  comments on issue #1: total=$COMMENTS_COUNT bot=$BOT_COMMENTS_COUNT llm-reply=$LLM_REPLIES"
+echo "  --- all bot comment bodies (first 400 chars each) ---"
+echo "$COMMENTS_JSON" | jq -r --arg bot "$BOT_LOGIN" \
+  '.[] | select(.user.login == $bot) | "  • " + (.body | .[0:400])' 2>/dev/null
+if [[ "$LLM_REPLIES" -ge 1 ]]; then
+  pass "bot auto-replied on issue #1 ($LLM_REPLIES [bot]-prefixed LLM reply)"
+else
+  echo "  --- daemon.log (last 40) ---"
+  tail -40 "$DATA_DIR/run/daemon.log" 2>/dev/null || echo "(no daemon.log)"
+  echo "  --- fake-llm.log (last 20) ---"
+  tail -20 /tmp/fake-llm.log 2>/dev/null
+  fail "bot did NOT post an LLM-driven reply on issue #1 (got $BOT_COMMENTS_COUNT bot comments but 0 starting with [bot])"
+fi
+
 info "drive headless browser through the UI"
 # bun (not tsx) because the script imports `bun:sqlite` to peek at opencode.db.
 cp /host-test/browser-flow.ts /tmp/test-runner/

package/scripts/fake-llm-server.ts

@@ -76,6 +76,9 @@ async function handleChatCompletion(req: Request): Promise<Response> {
   log(`  body: stream=${body?.stream} model=${body?.model} msgs=${body?.messages?.length} tools=${body?.tools?.length ?? 0}`);
 
   const messages = Array.isArray(body?.messages) ? body.messages : [];
+  const tools = Array.isArray(body?.tools) ? body.tools : [];
+  const lastMsg = messages[messages.length - 1];
+  const lastRole = lastMsg?.role;
   const userMsgs = messages.filter((m: any) => m?.role === "user");
   const lastUser = userMsgs[userMsgs.length - 1];
   const userText = typeof lastUser?.content === "string"
@@ -84,6 +87,36 @@ async function handleChatCompletion(req: Request): Promise<Response> {
       ? lastUser.content.map((p: any) => p?.text ?? "").join(" ")
       : "";
 
+  const hasReplyTool = tools.some((t: any) => t?.function?.name === "reply");
+
+  // Tool-call path: when `reply` is registered and the last message is the
+  // user's initial prompt (not a tool_result), emit a tool_use so opencode
+  // actually invokes the reply tool → ework-web posts a [bot] comment on the
+  // issue. Without this the daemon only posts its [system] "picked up"
+  // notification and the LLM-driven auto-reply loop never fires.
+  //
+  // After opencode executes the tool it makes a follow-up call with
+  // role=tool in the messages — at that point we drop back to text.
+  if (hasReplyTool && lastRole === "user") {
+    const ref = parseIssueRef(userText);
+    if (ref) {
+      log(`  emitting reply tool_use → ${ref.owner}/${ref.repo}#${ref.number}`);
+      const toolReplyBody =
+        `[bot] E2E fake-LLM auto-reply.\n\n` +
+        `Picked up ${ref.owner}/${ref.repo}#${ref.number}. ` +
+        `This is a stub reply emitted by scripts/fake-llm-server.ts to exercise ` +
+        `the opencode-ework \`reply\` tool end-to-end. The real value of this ` +
+        `test is that opencode received a tool_use, executed the reply tool, ` +
+        `and ework-web posted this comment as ${process.env.BOT_USERNAME ?? "bot"}.`;
+      return toolCallResponse(body?.model ?? "fake-model", "reply", {
+        owner: ref.owner,
+        repo: ref.repo,
+        number: ref.number,
+        body: toolReplyBody,
+      }, body?.stream === true);
+    }
+  }
+
   // Deterministic, context-aware reply: echo a snippet of the user's last
   // message so the session transcript has traceable content (not just a
   // fixed string). Truncated so the reply stays readable in the UI.
@@ -128,6 +161,133 @@ async function handleChatCompletion(req: Request): Promise<Response> {
   });
 }
 
+// Parse an issue ref of the form `<owner>/<repo>#<n>` out of arbitrary text
+// (typically the user prompt built by ework-daemon's buildInitialPrompt,
+// which includes "(gitea:owner/repo#N)"). Returns null if no match.
+function parseIssueRef(text: string): { owner: string; repo: string; number: number } | null {
+  const m = text.match(/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)#(\d+)/);
+  if (!m) return null;
+  const [, owner, repo, num] = m;
+  const number = parseInt(num, 10);
+  if (!Number.isFinite(number)) return null;
+  return { owner, repo, number };
+}
+
+// Emit a tool_use response (OpenAI function-calling format). Supports both
+// streaming and non-streaming because opencode defaults to stream=true but
+// curl smoke tests use non-streaming.
+function toolCallResponse(model: string, toolName: string, args: Record<string, unknown>, stream: boolean): Response {
+  const id = `chatcmpl-fake-${crypto.randomUUID()}`;
+  const created = Math.floor(Date.now() / 1000);
+  const callId = `call_${crypto.randomUUID().replace(/-/g, "").slice(0, 24)}`;
+  const argsJson = JSON.stringify(args);
+  const usage = {
+    prompt_tokens: roughTokens(argsJson),
+    completion_tokens: roughTokens(argsJson),
+    total_tokens: roughTokens(argsJson) * 2,
+  };
+
+  if (!stream) {
+    return json({
+      id,
+      object: "chat.completion",
+      created,
+      model,
+      choices: [
+        {
+          index: 0,
+          message: {
+            role: "assistant",
+            content: null,
+            tool_calls: [
+              {
+                id: callId,
+                type: "function",
+                function: { name: toolName, arguments: argsJson },
+              },
+            ],
+          },
+          finish_reason: "tool_calls",
+        },
+      ],
+      usage,
+    });
+  }
+
+  const encoder = new TextEncoder();
+  const readable = new ReadableStream({
+    start(controller) {
+      // Initial chunk: declare the tool_call with name + empty arguments.
+      controller.enqueue(
+        encoder.encode(
+          sseLine({
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: {
+                role: "assistant",
+                content: null,
+                tool_calls: [{
+                  index: 0,
+                  id: callId,
+                  type: "function",
+                  function: { name: toolName, arguments: "" },
+                }],
+              },
+              finish_reason: null,
+            }],
+          }),
+        ),
+      );
+      // Arguments chunk: full JSON in one shot (splitting is optional).
+      controller.enqueue(
+        encoder.encode(
+          sseLine({
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{
+              index: 0,
+              delta: {
+                tool_calls: [{ index: 0, function: { arguments: argsJson } }],
+              },
+              finish_reason: null,
+            }],
+          }),
+        ),
+      );
+      // Final chunk: finish_reason + usage.
+      controller.enqueue(
+        encoder.encode(
+          sseLine({
+            id,
+            object: "chat.completion.chunk",
+            created,
+            model,
+            choices: [{ index: 0, delta: {}, finish_reason: "tool_calls" }],
+            usage,
+          }),
+        ),
+      );
+      controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      controller.close();
+    },
+  });
+
+  return new Response(readable, {
+    headers: {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      "connection": "keep-alive",
+      "access-control-allow-origin": "*",
+    },
+  });
+}
+
 function streamResponse(model: string, reply: string, usage: any): Response {
   const id = `chatcmpl-fake-${crypto.randomUUID()}`;
   const created = Math.floor(Date.now() / 1000);