openfox 0.2.4 → 1.0.0

package/dist/agent-defaults/builder.agent.md

@@ -4,23 +4,19 @@ name: Builder
 description: Implements the task by writing code and completing criteria
 subagent: false
 color: '#3b82f6'
-tools:
+allowedTools:
   - read_file
-  - glob
-  - grep
   - web_fetch
   - write_file
   - edit_file
   - run_command
   - ask_user
-  - complete_criterion
-  - get_criteria
-  - todo_write
+  - criterion:complete,get
+  - todo:list,add,write,update,remove
   - call_sub_agent
   - load_skill
   - dev_server
   - step_done
-  - return_value
 ---
 
 # Build Mode

package/dist/agent-defaults/code-reviewer.agent.md

@@ -4,9 +4,8 @@ name: Code Reviewer
 description: Review code changes for quality, bugs, and best practices
 subagent: true
 color: '#3b82f6'
-tools:
+allowedTools:
   - read_file
-  - grep
   - web_fetch
 ---
 

package/dist/agent-defaults/debugger.agent.md

@@ -4,10 +4,9 @@ name: Debugger
 description: Analyze errors and suggest fixes
 subagent: true
 color: '#f97316'
-tools:
+allowedTools:
   - read_file
   - run_command
-  - grep
   - web_fetch
 ---
 

package/dist/agent-defaults/planner.agent.md

@@ -4,20 +4,13 @@ name: Planner
 description: Explores the codebase and defines criteria for the task
 subagent: false
 color: '#a855f7'
-tools:
+allowedTools:
   - read_file
-  - glob
-  - grep
   - web_fetch
   - run_command
-  - git
-  - get_criteria
-  - add_criterion
-  - update_criterion
-  - remove_criterion
+  - criterion:add,get,update,remove
   - call_sub_agent
   - load_skill
-  - return_value
 ---
 
 # Plan Mode

package/dist/agent-defaults/test-generator.agent.md

@@ -4,7 +4,7 @@ name: Test Generator
 description: Generate tests for implemented features
 subagent: true
 color: '#f59e0b'
-tools:
+allowedTools:
   - read_file
   - write_file
   - run_command

package/dist/agent-defaults/verifier.agent.md

@@ -4,11 +4,10 @@ name: Verifier
 description: Verifies completed criteria against actual code changes
 subagent: true
 color: '#22c55e'
-tools:
+allowedTools:
   - read_file
   - run_command
-  - pass_criterion
-  - fail_criterion
+  - criterion:pass,fail
   - web_fetch
 ---
 
@@ -28,8 +27,8 @@ For each criterion marked [NEEDS VERIFICATION]:
 4. Run tests or commands only if applicable to the criterion
 
 Then call:
-- `pass_criterion` if the criterion is satisfied
-- `fail_criterion` if it is NOT satisfied (explain why clearly)
+- `criterion` with action "pass" if the criterion is satisfied
+- `criterion` with action "fail" if it is NOT satisfied (explain why clearly)
 
 ## IMPORTANT
 - Start by analyzing what each criterion actually requires

package/dist/ask-3RK5YJZE.js

@@ -0,0 +1,19 @@
+import {
+  AskUserInterrupt,
+  askUserTool,
+  awaitAnswer,
+  cancelQuestion,
+  cancelQuestionsForSession,
+  hasPendingQuestion,
+  provideAnswer
+} from "./chunk-22CTURMH.js";
+export {
+  AskUserInterrupt,
+  askUserTool,
+  awaitAnswer,
+  cancelQuestion,
+  cancelQuestionsForSession,
+  hasPendingQuestion,
+  provideAnswer
+};
+//# sourceMappingURL=ask-3RK5YJZE.js.map

package/dist/auto-compaction-7LNZ5J3W.js

@@ -0,0 +1,23 @@
+import {
+  maybeAutoCompactContext,
+  performManualContextCompaction,
+  resolveCompactionStatsIdentity
+} from "./chunk-YB2574C6.js";
+import "./chunk-BU2ZYOEA.js";
+import "./chunk-2KSCZSXQ.js";
+import "./chunk-S4QKTRGJ.js";
+import "./chunk-22CTURMH.js";
+import "./chunk-7IOZFJBW.js";
+import "./chunk-XKFPU2FA.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-TPT6HP4H.js";
+import "./chunk-TVQOONDR.js";
+import "./chunk-XFXOSPYH.js";
+import "./chunk-5YQAXUKO.js";
+import "./chunk-PNBH3RAX.js";
+export {
+  maybeAutoCompactContext,
+  performManualContextCompaction,
+  resolveCompactionStatsIdentity
+};
+//# sourceMappingURL=auto-compaction-7LNZ5J3W.js.map

package/dist/{branch.api-WDHKZJS6.js → branch.api-XADFZZAA.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-U62ZECSQ.js";
+} from "./chunk-PNBH3RAX.js";
 
 // src/server/branch.api.ts
 import { spawn } from "child_process";
@@ -45,4 +45,4 @@ function getGitBranch(cwd) {
 export {
   getCurrentBranch
 };
-//# sourceMappingURL=branch.api-WDHKZJS6.js.map
+//# sourceMappingURL=branch.api-XADFZZAA.js.map

package/dist/chat-handler-T7SLWZ4E.js

@@ -0,0 +1,201 @@
+import {
+  runChatTurn
+} from "./chunk-VZXXJKSQ.js";
+import "./chunk-YB2574C6.js";
+import {
+  generateSessionName,
+  needsNameGeneration
+} from "./chunk-QDEKU5RL.js";
+import {
+  getEventStore,
+  updateSessionMetadata
+} from "./chunk-BU2ZYOEA.js";
+import {
+  buildMessagesFromStoredEvents,
+  foldPendingConfirmations
+} from "./chunk-2KSCZSXQ.js";
+import {
+  createChatMessageMessage,
+  createContextStateMessage,
+  createPhaseChangedMessage,
+  createSessionRunningMessage,
+  createSessionStateMessage
+} from "./chunk-S4QKTRGJ.js";
+import "./chunk-22CTURMH.js";
+import "./chunk-7IOZFJBW.js";
+import "./chunk-XKFPU2FA.js";
+import "./chunk-3EHGGBWE.js";
+import "./chunk-TPT6HP4H.js";
+import "./chunk-TVQOONDR.js";
+import "./chunk-XFXOSPYH.js";
+import "./chunk-5YQAXUKO.js";
+import {
+  logger
+} from "./chunk-PNBH3RAX.js";
+
+// src/server/session/chat-handler.ts
+var activeAgents = /* @__PURE__ */ new Map();
+async function startChatSession(sessionId, content, deps, options) {
+  const { sessionManager, llmClient, statsIdentity, broadcastForSession } = deps;
+  const session = sessionManager.getSession(sessionId);
+  if (!session) {
+    throw new Error("Session not found");
+  }
+  const eventStore = getEventStore();
+  if (session.isRunning) {
+    throw new Error("Session is already running");
+  }
+  if (session.phase === "blocked") {
+    sessionManager.setPhase(sessionId, "build");
+    sessionManager.resetAllCriteriaAttempts(sessionId);
+    broadcastForSession(sessionId, createPhaseChangedMessage("build"));
+  }
+  const controller = new AbortController();
+  const existingController = activeAgents.get(sessionId);
+  if (existingController) {
+    existingController.abort();
+  }
+  activeAgents.set(sessionId, controller);
+  sessionManager.setRunning(sessionId, true);
+  broadcastForSession(sessionId, createSessionRunningMessage(true));
+  try {
+    const { maybeAutoCompactContext } = await import("./auto-compaction-7LNZ5J3W.js");
+    await maybeAutoCompactContext({
+      sessionManager,
+      sessionId,
+      llmClient,
+      statsIdentity,
+      signal: controller.signal
+    });
+    if (controller.signal.aborted) {
+      return;
+    }
+    const userMessage = sessionManager.addMessage(sessionId, {
+      role: "user",
+      content,
+      ...options?.attachments && { attachments: options.attachments },
+      ...options?.messageKind && { messageKind: options.messageKind },
+      ...options?.isSystemGenerated && { isSystemGenerated: options.isSystemGenerated }
+    });
+    broadcastForSession(sessionId, createChatMessageMessage(userMessage));
+    const messageCount = getSessionMessageCount(sessionId);
+    const currentSession = sessionManager.getSession(sessionId);
+    logger.debug("Session name generation check", {
+      sessionId,
+      title: currentSession?.metadata.title,
+      messageCount,
+      needsGeneration: currentSession ? needsNameGeneration(currentSession.metadata.title, messageCount) : false
+    });
+    if (currentSession && needsNameGeneration(currentSession.metadata.title, messageCount)) {
+      generateSessionName({
+        userMessage: content,
+        llmClient,
+        signal: controller.signal
+      }).then((result) => {
+        logger.debug("Session name generation result", {
+          sessionId,
+          success: result.success,
+          name: result.name,
+          error: result.error
+        });
+        if (result.success && result.name) {
+          updateSessionMetadata(sessionId, { title: result.name });
+          eventStore.append(sessionId, {
+            type: "session.name_generated",
+            data: { name: result.name }
+          });
+          const updatedSession = sessionManager.getSession(sessionId);
+          if (updatedSession) {
+            const events = eventStore.getEvents(sessionId);
+            const messages = buildMessagesFromStoredEvents(events);
+            const pendingConfirmations = foldPendingConfirmations(events);
+            broadcastForSession(sessionId, createSessionStateMessage(updatedSession, messages, pendingConfirmations));
+          }
+        }
+      }).catch((error) => {
+        logger.error("Session name generation failed", {
+          sessionId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+    startTurnWithCompletionChain(sessionId, controller, deps);
+  } catch (error) {
+    if (activeAgents.get(sessionId) === controller) {
+      activeAgents.delete(sessionId);
+    }
+    sessionManager.setRunning(sessionId, false);
+    broadcastForSession(sessionId, createSessionRunningMessage(false));
+    const contextState = sessionManager.getContextState(sessionId);
+    broadcastForSession(sessionId, createContextStateMessage(contextState));
+    throw error;
+  }
+}
+function getSessionMessageCount(sessionId) {
+  const eventStore = getEventStore();
+  const events = eventStore.getEvents(sessionId);
+  let count = 0;
+  for (const event of events) {
+    if (event.type === "message.start") {
+      const data = event.data;
+      if (data.role === "user") {
+        count++;
+      }
+    }
+  }
+  return count;
+}
+function startTurnWithCompletionChain(sessionId, controller, deps) {
+  const { sessionManager, llmClient, statsIdentity, broadcastForSession } = deps;
+  runChatTurn({
+    sessionManager,
+    sessionId,
+    llmClient,
+    statsIdentity,
+    signal: controller.signal,
+    onMessage: (msg) => broadcastForSession(sessionId, msg)
+  }).catch((error) => {
+    if (error instanceof Error && error.message === "Aborted") {
+      return;
+    }
+  }).finally(() => {
+    if (activeAgents.get(sessionId) !== controller) {
+      return;
+    }
+    activeAgents.delete(sessionId);
+    const completionMsgs = sessionManager.drainCompletionMessages(sessionId);
+    const next = completionMsgs[0];
+    if (next) {
+      for (const remaining of completionMsgs.slice(1)) {
+        sessionManager.queueMessage(sessionId, "completion", remaining.content, remaining.attachments);
+      }
+      const userMessage = sessionManager.addMessage(sessionId, {
+        role: "user",
+        content: next.content,
+        ...next.attachments ? { attachments: next.attachments } : {}
+      });
+      broadcastForSession(sessionId, createChatMessageMessage(userMessage));
+      const newController = new AbortController();
+      activeAgents.set(sessionId, newController);
+      startTurnWithCompletionChain(sessionId, newController, deps);
+      return;
+    }
+    sessionManager.clearMessageQueue(sessionId);
+    sessionManager.setRunning(sessionId, false);
+    const contextState = sessionManager.getContextState(sessionId);
+    broadcastForSession(sessionId, createContextStateMessage(contextState));
+  });
+}
+function stopSessionExecution(sessionId, sessionManager) {
+  const controller = activeAgents.get(sessionId);
+  if (controller) {
+    activeAgents.delete(sessionId);
+    controller.abort();
+  }
+  sessionManager.setRunning(sessionId, false);
+}
+export {
+  startChatSession,
+  stopSessionExecution
+};
+//# sourceMappingURL=chat-handler-T7SLWZ4E.js.map

package/dist/chunk-22CTURMH.js

@@ -0,0 +1,128 @@
+// src/server/utils/async.ts
+function createDeferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+var EventEmitter = class {
+  listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    const listeners = this.listeners.get(event);
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+    };
+  }
+  emit(event, ...args) {
+    const listeners = this.listeners.get(event);
+    if (listeners) {
+      for (const listener of listeners) {
+        listener(...args);
+      }
+    }
+  }
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+};
+
+// src/server/tools/ask.ts
+var pendingQuestions = /* @__PURE__ */ new Map();
+var askUserTool = {
+  name: "ask_user",
+  definition: {
+    type: "function",
+    function: {
+      name: "ask_user",
+      description: "Pause execution and ask the user a question. Use this when you need clarification or user input before proceeding.",
+      parameters: {
+        type: "object",
+        properties: {
+          question: {
+            type: "string",
+            description: "The question to ask the user"
+          }
+        },
+        required: ["question"]
+      }
+    }
+  },
+  async execute(args, context) {
+    const question = args["question"];
+    const callId = crypto.randomUUID();
+    const deferred = createDeferred();
+    void deferred.promise.catch(() => {
+    });
+    pendingQuestions.set(callId, {
+      promise: deferred.promise,
+      resolve: deferred.resolve,
+      reject: deferred.reject,
+      sessionId: context.sessionId
+    });
+    throw new AskUserInterrupt(callId, question);
+  }
+};
+var AskUserInterrupt = class extends Error {
+  constructor(callId, question) {
+    super("Ask user interrupt");
+    this.callId = callId;
+    this.question = question;
+    this.name = "AskUserInterrupt";
+  }
+};
+function provideAnswer(callId, answer) {
+  const pending = pendingQuestions.get(callId);
+  if (!pending) {
+    return false;
+  }
+  pending.resolve(answer);
+  pendingQuestions.delete(callId);
+  return true;
+}
+function cancelQuestion(callId, reason) {
+  const pending = pendingQuestions.get(callId);
+  if (!pending) {
+    return false;
+  }
+  pending.reject(new Error(reason));
+  pendingQuestions.delete(callId);
+  return true;
+}
+function cancelQuestionsForSession(sessionId, reason) {
+  let cancelledCount = 0;
+  for (const [callId, pending] of pendingQuestions.entries()) {
+    if (pending.sessionId !== sessionId) {
+      continue;
+    }
+    pending.reject(new Error(reason));
+    pendingQuestions.delete(callId);
+    cancelledCount += 1;
+  }
+  return cancelledCount;
+}
+function hasPendingQuestion(callId) {
+  return pendingQuestions.has(callId);
+}
+function awaitAnswer(callId) {
+  const pending = pendingQuestions.get(callId);
+  return pending?.promise ?? null;
+}
+
+export {
+  EventEmitter,
+  askUserTool,
+  AskUserInterrupt,
+  provideAnswer,
+  cancelQuestion,
+  cancelQuestionsForSession,
+  hasPendingQuestion,
+  awaitAnswer
+};
+//# sourceMappingURL=chunk-22CTURMH.js.map