@askexenow/exe-os 0.9.280 → 0.9.281

package/dist/chunk-4AU56XV2.js

@@ -0,0 +1,58 @@
+import {
+  MODELS_DIR
+} from "./chunk-T3B5RK4H.js";
+
+// src/lib/reranker.ts
+import path from "path";
+import { existsSync } from "fs";
+var RERANKER_MODEL_FILE = process.env.EXE_RERANK_MODEL_FILE ?? "exe-reranker-v1-q4_k_m.gguf";
+function isRerankerAvailable() {
+  return existsSync(path.join(MODELS_DIR, RERANKER_MODEL_FILE));
+}
+function getRerankerModelPath() {
+  return path.join(MODELS_DIR, RERANKER_MODEL_FILE);
+}
+async function disposeReranker() {
+}
+async function rerankWithScores(query, texts, topK) {
+  if (texts.length === 0) return [];
+  const { rerankViaWorker } = await import("./lib/exe-daemon.js");
+  const scored = await rerankViaWorker(query, texts, topK);
+  return scored.map((s) => ({
+    text: texts[s.index] ?? "",
+    score: s.score,
+    index: s.index
+  }));
+}
+async function rerank(query, candidates, topK = 5) {
+  if (candidates.length === 0) return [];
+  if (candidates.length <= topK) return candidates;
+  const scored = await rerankWithScores(
+    query,
+    candidates.map((c) => c.raw_text),
+    topK
+  );
+  return scored.map((s) => candidates[s.index]);
+}
+async function rerankWithContext(query, candidates, topK) {
+  if (candidates.length === 0) return [];
+  const formattedTexts = candidates.map(
+    (c) => c.context ? `[${c.context}] ${c.text.slice(0, 460)}` : c.text.slice(0, 512)
+  );
+  const { rerankViaWorker } = await import("./lib/exe-daemon.js");
+  const scored = await rerankViaWorker(query, formattedTexts, topK);
+  return scored.map((s) => ({
+    text: candidates[s.index]?.text ?? "",
+    score: s.score,
+    index: s.index
+  }));
+}
+
+export {
+  isRerankerAvailable,
+  getRerankerModelPath,
+  disposeReranker,
+  rerankWithScores,
+  rerank,
+  rerankWithContext
+};

package/dist/chunk-4MRP6EBR.js

@@ -0,0 +1,280 @@
+import {
+  recordOrchestrationEventBestEffort
+} from "./chunk-MYEABW5Z.js";
+
+// src/lib/worktree.ts
+import { execSync } from "child_process";
+import { existsSync, readFileSync, appendFileSync, mkdirSync, realpathSync } from "fs";
+import path from "path";
+var GIT_TIMEOUT_MS = 1e4;
+function getGitRoot(dir) {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      cwd: dir,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return realpath(root);
+  } catch {
+    return null;
+  }
+}
+function getMainRepoRoot(dir) {
+  try {
+    const commonDir = execSync(
+      "git rev-parse --path-format=absolute --git-common-dir",
+      { cwd: dir, encoding: "utf-8", timeout: GIT_TIMEOUT_MS, stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    return realpath(path.dirname(commonDir));
+  } catch {
+    return null;
+  }
+}
+function worktreePath(repoRoot, employeeName, instance) {
+  const label = instanceLabel(employeeName, instance);
+  return path.join(repoRoot, ".worktrees", label);
+}
+function worktreeBranch(employeeName, instance, taskSlug) {
+  const label = instanceLabel(employeeName, instance);
+  if (taskSlug) {
+    const slug = taskSlug.slice(0, 40).replace(/[^a-z0-9-]/gi, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+    return `${label}-${slug}`;
+  }
+  return `${label}-work`;
+}
+function instanceLabel(name, instance) {
+  return instance != null && instance > 0 ? `${name}${instance}` : name;
+}
+function ensureWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getGitRoot(projectDir);
+  if (!repoRoot) return null;
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (existsSync(path.join(wtPath, ".git"))) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.reused",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch }
+    });
+    return wtPath;
+  }
+  const worktreesDir = path.join(repoRoot, ".worktrees");
+  mkdirSync(worktreesDir, { recursive: true });
+  ensureGitignoreEntry(repoRoot, "/.worktrees/");
+  try {
+    execSync("git worktree prune", {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  const branchExists = branchExistsLocally(repoRoot, branch);
+  try {
+    if (branchExists) {
+      execSync(`git worktree add "${wtPath}" "${branch}"`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } else {
+      execSync(`git worktree add "${wtPath}" -b "${branch}" HEAD`, {
+        cwd: repoRoot,
+        encoding: "utf-8",
+        timeout: GIT_TIMEOUT_MS,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    }
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.created",
+      source: "worktree.ensureWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { branch, reusedBranch: branchExists }
+    });
+    return wtPath;
+  } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.ensureWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_create_failed",
+      payload: { branch }
+    });
+    process.stderr.write(
+      `[worktree] Failed to create worktree for ${employeeName}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return null;
+  }
+}
+function isWorktreeDirty(wtPath) {
+  try {
+    const status = execSync("git status --porcelain", {
+      cwd: wtPath,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return status.length > 0;
+  } catch {
+    return true;
+  }
+}
+function cleanupWorktree(projectDir, employeeName, instance) {
+  const repoRoot = getMainRepoRoot(projectDir);
+  if (!repoRoot) return { cleaned: false, reason: "not a git repo" };
+  const wtPath = worktreePath(repoRoot, employeeName, instance);
+  const branch = worktreeBranch(employeeName, instance);
+  if (!existsSync(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree does not exist", branch }
+    });
+    return { cleaned: false, reason: "worktree does not exist" };
+  }
+  if (isWorktreeDirty(wtPath)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "worktree has uncommitted changes", branch }
+    });
+    return { cleaned: false, reason: "worktree has uncommitted changes" };
+  }
+  const mainBranch = detectMainBranch(repoRoot);
+  if (!mainBranch) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "could not determine main branch", branch }
+    });
+    return { cleaned: false, reason: "could not determine main branch" };
+  }
+  if (!isBranchMerged(repoRoot, branch, mainBranch)) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.skipped",
+      source: "worktree.cleanupWorktree",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      payload: { reason: "branch not merged", branch, mainBranch }
+    });
+    return { cleaned: false, reason: `branch ${branch} not merged into ${mainBranch}` };
+  }
+  try {
+    execSync(`git worktree remove "${wtPath}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (err) {
+    recordOrchestrationEventBestEffort({
+      eventType: "worktree.failed",
+      source: "worktree.cleanupWorktree",
+      severity: "warn",
+      agentId: employeeName,
+      instanceId: instance != null ? String(instance) : null,
+      errorCode: err instanceof Error ? err.name : "worktree_remove_failed",
+      payload: { branch, mainBranch }
+    });
+    return {
+      cleaned: false,
+      reason: `git worktree remove failed: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  try {
+    execSync(`git branch -d "${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+  }
+  recordOrchestrationEventBestEffort({
+    eventType: "worktree.pruned",
+    source: "worktree.cleanupWorktree",
+    agentId: employeeName,
+    instanceId: instance != null ? String(instance) : null,
+    payload: { branch, mainBranch }
+  });
+  return { cleaned: true, reason: `worktree and branch ${branch} removed (merged into ${mainBranch})` };
+}
+function branchExistsLocally(repoRoot, branch) {
+  try {
+    execSync(`git rev-parse --verify "refs/heads/${branch}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectMainBranch(repoRoot) {
+  for (const candidate of ["main", "master"]) {
+    if (branchExistsLocally(repoRoot, candidate)) return candidate;
+  }
+  return null;
+}
+function isBranchMerged(repoRoot, branch, into) {
+  try {
+    const merged = execSync(`git branch --merged "${into}"`, {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return merged.split("\n").map((l) => l.replace(/^[*+]?\s+/, "").trim()).includes(branch);
+  } catch {
+    return false;
+  }
+}
+function realpath(p) {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function ensureGitignoreEntry(repoRoot, entry) {
+  try {
+    const gitignorePath = path.join(repoRoot, ".gitignore");
+    if (existsSync(gitignorePath)) {
+      const content = readFileSync(gitignorePath, "utf-8");
+      if (content.includes(entry)) return;
+      appendFileSync(gitignorePath, `
+# Agent worktrees (exe-os)
+${entry}
+`);
+    } else {
+    }
+  } catch {
+  }
+}
+
+export {
+  getGitRoot,
+  getMainRepoRoot,
+  worktreePath,
+  worktreeBranch,
+  ensureWorktree,
+  isWorktreeDirty,
+  cleanupWorktree
+};