@gulbanana/jagman 0.0.1

package/build/server/chunks/agent-C7A3zEr3.js

@@ -0,0 +1,708 @@
+import { g as get_request_store, w as with_request_store } from './root-C5lyo0VT.js';
+import { s as stringify_remote_arg, c as create_remote_key, h as handle_error_and_jsonify } from './shared-bytReIJX.js';
+import { e as error, H as HttpError, S as SvelteKitError } from './index-CoD1IJuy.js';
+import { homedir } from 'node:os';
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createReadStream } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { O as OpenCodeAgent, g as getAgentProcesses, a as getWorkspacesWithAgent, m as markExternalSessions } from './opencode-vgZ5DMQ2.js';
+
+/** @import { RemoteInfo } from 'types' */
+
+/** @type {RemoteInfo['type'][]} */
+const types = ['command', 'form', 'prerender', 'query', 'query_batch'];
+
+/**
+ * @param {Record<string, any>} module
+ * @param {string} file
+ * @param {string} hash
+ */
+function init_remote_functions(module, file, hash) {
+	if (module.default) {
+		throw new Error(
+			`Cannot export \`default\` from a remote module (${file}) — please use named exports instead`
+		);
+	}
+
+	for (const [name, fn] of Object.entries(module)) {
+		if (!types.includes(fn?.__?.type)) {
+			throw new Error(
+				`\`${name}\` exported from ${file} is invalid — all exports from this file must be remote functions`
+			);
+		}
+
+		fn.__.id = `${hash}/${name}`;
+		fn.__.name = name;
+	}
+}
+
+function create_validator(validate_or_fn, maybe_fn) {
+  if (!maybe_fn) {
+    return (arg) => {
+      if (arg !== void 0) {
+        error(400, "Bad Request");
+      }
+    };
+  }
+  if (validate_or_fn === "unchecked") {
+    return (arg) => arg;
+  }
+  if ("~standard" in validate_or_fn) {
+    return async (arg) => {
+      const { event, state } = get_request_store();
+      const result = await validate_or_fn["~standard"].validate(arg);
+      if (result.issues) {
+        error(
+          400,
+          await state.handleValidationError({
+            issues: result.issues,
+            event
+          })
+        );
+      }
+      return result.value;
+    };
+  }
+  throw new Error(
+    'Invalid validator passed to remote function. Expected "unchecked" or a Standard Schema (https://standardschema.dev)'
+  );
+}
+async function get_response(info, arg, state, get_result) {
+  await 0;
+  const cache = get_cache(info, state);
+  return cache[stringify_remote_arg(arg, state.transport)] ??= get_result();
+}
+async function run_remote_function(event, state, allow_cookies, get_input, fn) {
+  const store = {
+    event: {
+      ...event,
+      setHeaders: () => {
+        throw new Error("setHeaders is not allowed in remote functions");
+      },
+      cookies: {
+        ...event.cookies,
+        set: (name, value, opts) => {
+          {
+            throw new Error("Cannot set cookies in `query` or `prerender` functions");
+          }
+        },
+        delete: (name, opts) => {
+          {
+            throw new Error("Cannot delete cookies in `query` or `prerender` functions");
+          }
+        }
+      }
+    },
+    state: {
+      ...state,
+      is_in_remote_function: true
+    }
+  };
+  const input = await with_request_store(store, get_input);
+  return with_request_store(store, () => fn(input));
+}
+function get_cache(info, state = get_request_store().state) {
+  let cache = state.remote_data?.get(info);
+  if (cache === void 0) {
+    cache = {};
+    (state.remote_data ??= /* @__PURE__ */ new Map()).set(info, cache);
+  }
+  return cache;
+}
+// @__NO_SIDE_EFFECTS__
+function query(validate_or_fn, maybe_fn) {
+  const fn = maybe_fn ?? validate_or_fn;
+  const validate = create_validator(validate_or_fn, maybe_fn);
+  const __ = { type: "query", id: "", name: "" };
+  const wrapper = (arg) => {
+    const { event, state } = get_request_store();
+    const get_remote_function_result = () => run_remote_function(event, state, false, () => validate(arg), fn);
+    const promise = get_response(__, arg, state, get_remote_function_result);
+    promise.catch(() => {
+    });
+    promise.set = (value) => update_refresh_value(get_refresh_context(__, "set", arg), value);
+    promise.refresh = () => {
+      const refresh_context = get_refresh_context(__, "refresh", arg);
+      const is_immediate_refresh = !refresh_context.cache[refresh_context.cache_key];
+      const value = is_immediate_refresh ? promise : get_remote_function_result();
+      return update_refresh_value(refresh_context, value, is_immediate_refresh);
+    };
+    promise.withOverride = () => {
+      throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
+    };
+    return (
+      /** @type {RemoteQuery<Output>} */
+      promise
+    );
+  };
+  Object.defineProperty(wrapper, "__", { value: __ });
+  return wrapper;
+}
+// @__NO_SIDE_EFFECTS__
+function batch(validate_or_fn, maybe_fn) {
+  const fn = maybe_fn ?? validate_or_fn;
+  const validate = create_validator(validate_or_fn, maybe_fn);
+  const __ = {
+    type: "query_batch",
+    id: "",
+    name: "",
+    run: async (args, options) => {
+      const { event, state } = get_request_store();
+      return run_remote_function(
+        event,
+        state,
+        false,
+        async () => Promise.all(args.map(validate)),
+        async (input) => {
+          const get_result = await fn(input);
+          return Promise.all(
+            input.map(async (arg, i) => {
+              try {
+                return { type: "result", data: get_result(arg, i) };
+              } catch (error2) {
+                return {
+                  type: "error",
+                  error: await handle_error_and_jsonify(event, state, options, error2),
+                  status: error2 instanceof HttpError || error2 instanceof SvelteKitError ? error2.status : 500
+                };
+              }
+            })
+          );
+        }
+      );
+    }
+  };
+  let batching = { args: [], resolvers: [] };
+  const wrapper = (arg) => {
+    const { event, state } = get_request_store();
+    const get_remote_function_result = () => {
+      return new Promise((resolve, reject) => {
+        batching.args.push(arg);
+        batching.resolvers.push({ resolve, reject });
+        if (batching.args.length > 1) return;
+        setTimeout(async () => {
+          const batched = batching;
+          batching = { args: [], resolvers: [] };
+          try {
+            return await run_remote_function(
+              event,
+              state,
+              false,
+              async () => Promise.all(batched.args.map(validate)),
+              async (input) => {
+                const get_result = await fn(input);
+                for (let i = 0; i < batched.resolvers.length; i++) {
+                  try {
+                    batched.resolvers[i].resolve(get_result(input[i], i));
+                  } catch (error2) {
+                    batched.resolvers[i].reject(error2);
+                  }
+                }
+              }
+            );
+          } catch (error2) {
+            for (const resolver of batched.resolvers) {
+              resolver.reject(error2);
+            }
+          }
+        }, 0);
+      });
+    };
+    const promise = get_response(__, arg, state, get_remote_function_result);
+    promise.catch(() => {
+    });
+    promise.set = (value) => update_refresh_value(get_refresh_context(__, "set", arg), value);
+    promise.refresh = () => {
+      const refresh_context = get_refresh_context(__, "refresh", arg);
+      const is_immediate_refresh = !refresh_context.cache[refresh_context.cache_key];
+      const value = is_immediate_refresh ? promise : get_remote_function_result();
+      return update_refresh_value(refresh_context, value, is_immediate_refresh);
+    };
+    promise.withOverride = () => {
+      throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
+    };
+    return (
+      /** @type {RemoteQuery<Output>} */
+      promise
+    );
+  };
+  Object.defineProperty(wrapper, "__", { value: __ });
+  return wrapper;
+}
+Object.defineProperty(query, "batch", { value: batch, enumerable: true });
+function get_refresh_context(__, action, arg) {
+  const { state } = get_request_store();
+  const { refreshes } = state;
+  if (!refreshes) {
+    const name = __.type === "query_batch" ? `query.batch '${__.name}'` : `query '${__.name}'`;
+    throw new Error(
+      `Cannot call ${action} on ${name} because it is not executed in the context of a command/form remote function`
+    );
+  }
+  const cache = get_cache(__, state);
+  const cache_key = stringify_remote_arg(arg, state.transport);
+  const refreshes_key = create_remote_key(__.id, cache_key);
+  return { __, state, refreshes, refreshes_key, cache, cache_key };
+}
+function update_refresh_value({ __, refreshes, refreshes_key, cache, cache_key }, value, is_immediate_refresh = false) {
+  const promise = Promise.resolve(value);
+  if (!is_immediate_refresh) {
+    cache[cache_key] = promise;
+  }
+  if (__.id) {
+    refreshes[refreshes_key] = promise;
+  }
+  return promise.then(() => {
+  });
+}
+
+const REPO_PATHS = [
+  "C:\\Users\\banana\\Documents\\code\\jagman",
+  "C:\\Users\\banana\\Documents\\code\\gg",
+  "C:\\Users\\banana\\Documents\\code\\lockhaven"
+];
+let activeOrder = [];
+function updateActiveOrder(sessions) {
+  const currentlyActive = new Set(
+    sessions.filter((s) => s.status === "running" || s.status === "waiting" || s.status === "external").map((s) => s.id)
+  );
+  activeOrder = activeOrder.filter((id) => currentlyActive.has(id));
+  const existing = new Set(activeOrder);
+  const newlyActive = [...currentlyActive].filter((id) => !existing.has(id));
+  activeOrder = [...newlyActive, ...activeOrder];
+  return activeOrder;
+}
+function parseRecord(line) {
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (obj.type === "user" && obj.message) {
+    const msg = obj.message;
+    return {
+      type: "user",
+      uuid: obj.uuid ?? "",
+      parentUuid: obj.parentUuid ?? null,
+      timestamp: obj.timestamp ?? "",
+      sessionId: obj.sessionId ?? "",
+      slug: obj.slug ?? null,
+      permissionMode: obj.permissionMode ?? null,
+      cwd: obj.cwd ?? "",
+      gitBranch: obj.gitBranch ?? "",
+      isSidechain: obj.isSidechain ?? false,
+      message: {
+        role: "user",
+        content: msg.content
+      }
+    };
+  }
+  if (obj.type === "assistant" && obj.message) {
+    const msg = obj.message;
+    return {
+      type: "assistant",
+      uuid: obj.uuid ?? "",
+      parentUuid: obj.parentUuid ?? null,
+      timestamp: obj.timestamp ?? "",
+      isSidechain: obj.isSidechain ?? false,
+      message: {
+        role: "assistant",
+        model: msg.model ?? "",
+        content: msg.content ?? [],
+        stop_reason: msg.stop_reason ?? null
+      }
+    };
+  }
+  return null;
+}
+async function scanSession(filePath, visitor) {
+  const stream = createReadStream(filePath, { encoding: "utf-8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      const record = parseRecord(line);
+      if (record) {
+        const cont = visitor(record);
+        if (cont === false) break;
+      }
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+}
+async function readFirstUserRecord(filePath) {
+  let result = null;
+  await scanSession(filePath, (record) => {
+    if (record.type === "user") {
+      result = record;
+      return false;
+    }
+  });
+  return result;
+}
+async function readSessionOverview(filePath) {
+  let sessionId = null;
+  let cwd = "";
+  let gitBranch = "";
+  let permissionMode = null;
+  let hasContent = false;
+  let lastTimestamp = "";
+  let lastAssistantText = null;
+  let firstUserText = null;
+  await scanSession(filePath, (record) => {
+    if (record.timestamp > lastTimestamp) {
+      lastTimestamp = record.timestamp;
+    }
+    if (record.type === "user") {
+      if (sessionId === null) {
+        sessionId = record.sessionId;
+        cwd = record.cwd;
+        gitBranch = record.gitBranch;
+      }
+      if (record.permissionMode !== null) permissionMode = record.permissionMode;
+      if (!record.isSidechain && firstUserText === null) {
+        const text = getUserText(record);
+        if (text && !isMetaMessage(record)) {
+          hasContent = true;
+          firstUserText = text;
+        }
+      }
+    } else if (record.type === "assistant" && !record.isSidechain) {
+      hasContent = true;
+      const text = getAssistantText(record);
+      if (text) lastAssistantText = text;
+    }
+  });
+  if (!sessionId) return null;
+  return { sessionId, cwd, gitBranch, permissionMode, hasContent, lastTimestamp, lastAssistantText, firstUserText };
+}
+async function readAllRecords(filePath) {
+  const records = [];
+  await scanSession(filePath, (record) => {
+    if (!record.isSidechain) {
+      records.push(record);
+    }
+  });
+  return records;
+}
+function isIdeTag(text) {
+  const trimmed = text.trimStart();
+  return trimmed.startsWith("<ide_selection") || trimmed.startsWith("<ide_opened_file");
+}
+function getUserText(record) {
+  const content = record.message.content;
+  if (typeof content === "string") return content.trim();
+  return content.filter((b) => b.type === "text" && b.text.trim() !== "" && !isIdeTag(b.text)).map((b) => b.text).join("\n").trim();
+}
+function getAssistantText(record) {
+  return record.message.content.filter((b) => b.type === "text" && b.text.trim() !== "").map((b) => b.text).join("\n").trim();
+}
+function isMetaMessage(record) {
+  const text = getUserText(record).trimStart();
+  return text.startsWith("<command-name>") || text.startsWith("<local-command-stdout>") || text.startsWith("<local-command-caveat>");
+}
+function getToolUses(record) {
+  return record.message.content.filter((b) => b.type === "tool_use").map((b) => ({ id: b.id, name: b.name, input: b.input }));
+}
+function getToolResults(record) {
+  const content = record.message.content;
+  if (typeof content === "string") return [];
+  return content.filter((b) => b.type === "tool_result").map((b) => ({ toolUseId: b.tool_use_id, isError: b.is_error }));
+}
+const PROJECTS_DIR = join(homedir(), ".claude", "projects");
+let projectIndex = null;
+const sessionFileCache = /* @__PURE__ */ new Map();
+function firstLine(text) {
+  const nl = text.indexOf("\n");
+  return nl === -1 ? text : text.slice(0, nl);
+}
+function mapPermissionMode(permissionMode) {
+  switch (permissionMode) {
+    case "default":
+    case "acceptEdits":
+      return "standard";
+    case "plan":
+      return "plan";
+    case "bypassPermissions":
+      return "yolo";
+    default:
+      return null;
+  }
+}
+async function buildProjectIndex() {
+  const index = /* @__PURE__ */ new Map();
+  let dirs;
+  try {
+    dirs = await readdir(PROJECTS_DIR);
+  } catch {
+    return index;
+  }
+  await Promise.all(
+    dirs.map(async (dirName) => {
+      const dirPath = join(PROJECTS_DIR, dirName);
+      try {
+        const s = await stat(dirPath);
+        if (!s.isDirectory()) return;
+      } catch {
+        return;
+      }
+      let entries;
+      try {
+        entries = await readdir(dirPath);
+      } catch {
+        return;
+      }
+      const firstJsonl = entries.find((e) => e.endsWith(".jsonl"));
+      if (!firstJsonl) return;
+      const record = await readFirstUserRecord(join(dirPath, firstJsonl));
+      if (record) {
+        index.set(record.cwd.toLowerCase(), dirName);
+      }
+    })
+  );
+  return index;
+}
+async function getProjectIndex() {
+  if (!projectIndex) {
+    projectIndex = await buildProjectIndex();
+  }
+  return projectIndex;
+}
+async function readProjectSessions(projectDirName, workspace) {
+  const projectPath = join(PROJECTS_DIR, projectDirName);
+  let allEntries;
+  try {
+    allEntries = await readdir(projectPath);
+  } catch {
+    return { sessions: [], branch: "" };
+  }
+  const jsonlFiles = allEntries.filter((e) => e.endsWith(".jsonl"));
+  const headers = await Promise.all(
+    jsonlFiles.map(async (file) => {
+      const filePath = join(projectPath, file);
+      const overview = await readSessionOverview(filePath);
+      if (!overview || !overview.hasContent) return null;
+      sessionFileCache.set(overview.sessionId, filePath);
+      return {
+        sessionId: overview.sessionId,
+        title: overview.firstUserText ? firstLine(overview.firstUserText) : overview.sessionId,
+        mode: mapPermissionMode(overview.permissionMode),
+        timestamp: new Date(overview.lastTimestamp).getTime(),
+        gitBranch: overview.gitBranch,
+        lastAssistantText: overview.lastAssistantText
+      };
+    })
+  );
+  const sessionHeaders = headers.filter((h) => h !== null);
+  const branch = sessionHeaders[0]?.gitBranch ?? "";
+  const sessions = sessionHeaders.map((session) => ({
+    id: session.sessionId,
+    workspace,
+    status: "inactive",
+    mode: session.mode,
+    title: session.title,
+    timestamp: session.timestamp,
+    lastAssistantText: session.lastAssistantText
+  }));
+  return { sessions, branch };
+}
+async function findSessionFile(sessionId) {
+  const cached = sessionFileCache.get(sessionId);
+  if (cached) return cached;
+  const index = await getProjectIndex();
+  const targetFilename = `${sessionId}.jsonl`;
+  for (const [, projectDirName] of index) {
+    const projectPath = join(PROJECTS_DIR, projectDirName);
+    let entries;
+    try {
+      entries = await readdir(projectPath);
+    } catch {
+      continue;
+    }
+    if (entries.includes(targetFilename)) {
+      const filePath = join(projectPath, targetFilename);
+      sessionFileCache.set(sessionId, filePath);
+      return filePath;
+    }
+  }
+  return null;
+}
+class ClaudeAgent {
+  brand = "cc";
+  async loadRepos(repoPaths) {
+    const index = await getProjectIndex();
+    const repos = await Promise.all(
+      repoPaths.map(async (repoPath) => {
+        const projectDirName = index.get(repoPath.toLowerCase());
+        if (!projectDirName) {
+          return { path: repoPath, branch: "HEAD", sessions: [] };
+        }
+        const { sessions, branch } = await readProjectSessions(projectDirName, repoPath);
+        return {
+          path: repoPath,
+          branch: branch || "HEAD",
+          sessions
+        };
+      })
+    );
+    const processes = await getAgentProcesses();
+    const activeWorkspaces = getWorkspacesWithAgent(processes, "claude");
+    markExternalSessions(repos.flatMap((r) => r.sessions), activeWorkspaces);
+    return repos;
+  }
+  async loadSession(id) {
+    const filePath = await findSessionFile(id);
+    if (!filePath) return null;
+    const records = await readAllRecords(filePath);
+    const firstUser = records.find((r) => r.type === "user");
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      if (record.type === "user") {
+        for (const { toolUseId, isError } of getToolResults(record)) {
+          resultMap.set(toolUseId, !isError);
+        }
+      }
+    }
+    const log = [];
+    for (const record of records) {
+      if (record.type === "user") {
+        const text = getUserText(record);
+        if (text && !isMetaMessage(record)) {
+          log.push({ type: "user", text, timestamp: record.timestamp });
+        }
+      } else {
+        const text = getAssistantText(record);
+        if (text) {
+          log.push({ type: "assistant", text, timestamp: record.timestamp });
+        }
+        for (const { id: toolId, name, input } of getToolUses(record)) {
+          log.push({
+            type: "tool_use",
+            tool: name,
+            args: new Map(Object.entries(input)),
+            success: resultMap.get(toolId) ?? true,
+            timestamp: record.timestamp
+          });
+        }
+      }
+    }
+    const firstUserText = firstUser ? getUserText(firstUser) : null;
+    const title = firstUserText && !isMetaMessage(firstUser) ? firstLine(firstUserText) : id;
+    return {
+      id,
+      title,
+      log
+    };
+  }
+}
+let wellKnownAgents = [new ClaudeAgent(), new OpenCodeAgent()];
+const HOME = homedir();
+function toDisplayPath(path) {
+  if (path.toLowerCase().startsWith(HOME.toLowerCase())) {
+    return "~" + path.slice(HOME.length);
+  }
+  return path;
+}
+async function getAllRepos() {
+  const repoMap = /* @__PURE__ */ new Map();
+  const agentErrors = [];
+  for (const agent of wellKnownAgents) {
+    let agentRepos;
+    try {
+      agentRepos = await agent.loadRepos(REPO_PATHS);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      agentErrors.push({ brand: agent.brand, message });
+      continue;
+    }
+    for (const repo of agentRepos) {
+      const key = repo.path.toLowerCase();
+      const existing = repoMap.get(key);
+      const brandedSessions = repo.sessions.map((s) => ({ ...s, mode: s.status == "inactive" ? null : s.mode, brand: agent.brand }));
+      if (existing) {
+        existing.sessions.push(...brandedSessions);
+        if (!existing.branch || existing.branch === "HEAD") {
+          existing.branch = repo.branch;
+        }
+      } else {
+        repoMap.set(key, {
+          path: repo.path,
+          branch: repo.branch,
+          sessions: brandedSessions,
+          errors: []
+        });
+      }
+    }
+  }
+  for (const repoPath of REPO_PATHS) {
+    const key = repoPath.toLowerCase();
+    if (!repoMap.has(key)) {
+      repoMap.set(key, {
+        path: repoPath,
+        branch: "",
+        sessions: [],
+        errors: []
+      });
+    }
+  }
+  if (agentErrors.length > 0) {
+    for (const repo of repoMap.values()) {
+      repo.errors.push(...agentErrors);
+    }
+  }
+  const repos = [...repoMap.values()];
+  const allSessions = repos.flatMap((r) => r.sessions);
+  const order = updateActiveOrder(allSessions);
+  const activeIndex = new Map(order.map((id, i) => [id, i]));
+  for (const repo of repos) {
+    repo.sessions.sort((a, b) => {
+      const aActive = activeIndex.has(a.id);
+      const bActive = activeIndex.has(b.id);
+      if (aActive && !bActive) return -1;
+      if (!aActive && bActive) return 1;
+      if (aActive && bActive) {
+        return activeIndex.get(a.id) - activeIndex.get(b.id);
+      }
+      return b.timestamp - a.timestamp;
+    });
+  }
+  repos.sort((a, b) => {
+    const aTime = a.sessions[0]?.timestamp ?? 0;
+    const bTime = b.sessions[0]?.timestamp ?? 0;
+    return bTime - aTime;
+  });
+  return repos.map((repo) => ({
+    path: toDisplayPath(repo.path),
+    branch: repo.branch,
+    sessions: repo.sessions,
+    errors: repo.errors
+  }));
+}
+async function getAgentSession(id) {
+  const results = await Promise.allSettled(
+    wellKnownAgents.map((agent) => agent.loadSession(id))
+  );
+  const errors = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "fulfilled" && result.value) {
+      return { ...result.value, brand: wellKnownAgents[i].brand };
+    }
+    if (result.status === "rejected") {
+      const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+      errors.push({ brand: wellKnownAgents[i].brand, message });
+    }
+  }
+  if (errors.length > 0) {
+    const detail = errors.map((e) => `[${e.brand}] ${e.message}`).join("\n");
+    throw new Error(`Session not found. Agent errors:
+${detail}`);
+  }
+  return null;
+}
+
+export { getAgentSession as a, getAllRepos as g, init_remote_functions as i, query as q };
+//# sourceMappingURL=agent-C7A3zEr3.js.map