@rallycry/conveyor-agent 6.4.2 → 7.0.1

package/dist/index.js

@@ -1,16 +1,91 @@
 import {
-  AgentRunner,
-  ConveyorConnection,
-  FileCache,
+  AgentConnection,
+  CommitWatcher,
+  DEFAULT_LIFECYCLE_CONFIG,
+  Lifecycle,
+  ModeController,
+  PlanSync,
   ProjectConnection,
   ProjectRunner,
+  SessionRunner,
+  detachWorktreeBranch,
   ensureWorktree,
+  getCurrentBranch,
+  hasUncommittedChanges,
+  hasUnpushedCommits,
   injectTelemetry,
-  loadConveyorConfig,
+  pushToOrigin,
   removeWorktree,
+  runAuthTokenCommand,
   runSetupCommand,
-  runStartCommand
-} from "./chunk-XHJ2Z4AD.js";
+  runStartCommand,
+  stageAndCommit,
+  updateRemoteToken
+} from "./chunk-HAU4E7IA.js";
+
+// src/runner/file-cache.ts
+var DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+var FileCache = class {
+  cache = /* @__PURE__ */ new Map();
+  currentSize = 0;
+  maxSizeBytes;
+  ttlMs;
+  constructor(maxSizeBytes = DEFAULT_MAX_SIZE_BYTES, ttlMs = DEFAULT_TTL_MS) {
+    this.maxSizeBytes = maxSizeBytes;
+    this.ttlMs = ttlMs;
+  }
+  get(fileId) {
+    const entry = this.cache.get(fileId);
+    if (!entry) return null;
+    if (Date.now() - entry.createdAt > this.ttlMs) {
+      this.delete(fileId);
+      return null;
+    }
+    this.cache.delete(fileId);
+    this.cache.set(fileId, entry);
+    return entry;
+  }
+  set(fileId, content, mimeType, fileName) {
+    if (this.cache.has(fileId)) {
+      this.delete(fileId);
+    }
+    const size = content.byteLength;
+    if (size > this.maxSizeBytes) return;
+    while (this.currentSize + size > this.maxSizeBytes && this.cache.size > 0) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey !== void 0) {
+        this.delete(oldestKey);
+      }
+    }
+    this.cache.set(fileId, {
+      content,
+      mimeType,
+      fileName,
+      createdAt: Date.now(),
+      size
+    });
+    this.currentSize += size;
+  }
+  delete(fileId) {
+    const entry = this.cache.get(fileId);
+    if (entry) {
+      this.currentSize -= entry.size;
+      this.cache.delete(fileId);
+    }
+  }
+  clear() {
+    this.cache.clear();
+    this.currentSize = 0;
+  }
+  get stats() {
+    return {
+      entries: this.cache.size,
+      sizeBytes: this.currentSize,
+      maxSizeBytes: this.maxSizeBytes
+    };
+  }
+};
 
 // src/debug/cdp-client.ts
 var MAX_VARIABLE_VALUE_BYTES = 2048;
@@ -1155,7 +1230,10 @@ var DebugLifecycleManager = class {
   requestReproduce(hypothesis) {
     this.reproduceRequested = true;
     if (hypothesis) this.hypothesis = hypothesis;
-    this.connection.emitDebugReproduceRequested(hypothesis ?? this.hypothesis);
+    this.connection.sendEvent({
+      type: "debug_reproduce_requested",
+      hypothesis: hypothesis ?? this.hypothesis
+    });
     this.broadcastState();
   }
   /** Add a telemetry event to the debug session */
@@ -1185,7 +1263,7 @@ var DebugLifecycleManager = class {
       startedAt,
       endedAt
     };
-    this.connection.emitDebugSessionComplete(summary);
+    this.connection.sendEvent({ type: "debug_session_complete", summary });
     this._isActive = false;
     this.hypothesis = void 0;
     this.sessionStartedAt = void 0;
@@ -1263,22 +1341,221 @@ var DebugLifecycleManager = class {
     };
   }
   broadcastState() {
-    this.connection.emitDebugStateChanged(this.buildState());
+    this.connection.sendEvent({
+      type: "debug_state_changed",
+      state: this.buildState()
+    });
+  }
+};
+
+// src/debug/hypothesis-tracker.ts
+var MAX_ITERATIONS = 3;
+var HypothesisTracker = class {
+  hypothesis = null;
+  iteration = 0;
+  observations = [];
+  _active = false;
+  conclusion = null;
+  // ── Public API ─────────────────────────────────────────────────────────
+  /**
+   * Start or update the current debugging hypothesis.
+   * Increments the iteration count if a hypothesis was already set.
+   */
+  setHypothesis(text) {
+    if (!this._active) {
+      this._active = true;
+      this.hypothesis = text;
+      this.iteration = 1;
+      this.observations = [];
+      this.conclusion = null;
+      return { accepted: true, message: `Hypothesis set (iteration 1/${MAX_ITERATIONS}): ${text}` };
+    }
+    if (this.iteration >= MAX_ITERATIONS) {
+      return {
+        accepted: false,
+        message: `Max iterations (${MAX_ITERATIONS}) reached. You must make a decision based on what you've observed. Use concludeSession() to summarize findings and exit debug mode.`
+      };
+    }
+    this.iteration++;
+    this.hypothesis = text;
+    return {
+      accepted: true,
+      message: `Hypothesis updated (iteration ${this.iteration}/${MAX_ITERATIONS}): ${text}`
+    };
+  }
+  /**
+   * Record an observation from debug data (breakpoint hit, telemetry, etc.).
+   */
+  recordObservation(description, confirmsHypothesis) {
+    this.observations.push({
+      description,
+      confirmsHypothesis,
+      iteration: this.iteration,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * End the debug session with a conclusion.
+   */
+  concludeSession(conclusion) {
+    this.conclusion = conclusion;
+    this._active = false;
+    const summary = this.getSessionSummary();
+    this.reset();
+    return summary;
+  }
+  /**
+   * Get formatted debug context for injection into the agent's system prompt.
+   * Returns empty string if no active session.
+   */
+  getDebugContext() {
+    if (!this._active || !this.hypothesis) return "";
+    const lines = [
+      `Current debug session (iteration ${this.iteration}/${MAX_ITERATIONS}):`,
+      `Hypothesis: "${this.hypothesis}"`
+    ];
+    if (this.observations.length > 0) {
+      const byIteration = /* @__PURE__ */ new Map();
+      for (const obs of this.observations) {
+        const group = byIteration.get(obs.iteration) ?? [];
+        group.push(obs);
+        byIteration.set(obs.iteration, group);
+      }
+      for (const [iter, iterObs] of byIteration) {
+        for (const obs of iterObs) {
+          const verdict = obs.confirmsHypothesis ? "SUPPORTS" : "CONTRADICTS";
+          lines.push(`Iteration ${iter}: ${obs.description} \u2014 ${verdict} hypothesis`);
+        }
+      }
+    }
+    if (this.iteration >= MAX_ITERATIONS) {
+      lines.push(
+        `\u26A0\uFE0F Final iteration reached. Analyze observations and make a decision \u2014 no more debug iterations available.`
+      );
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get the full state (for serialization/testing).
+   */
+  getState() {
+    return {
+      hypothesis: this.hypothesis,
+      iteration: this.iteration,
+      observations: [...this.observations],
+      active: this._active,
+      conclusion: this.conclusion
+    };
+  }
+  isActive() {
+    return this._active;
+  }
+  getIteration() {
+    return this.iteration;
+  }
+  getMaxIterations() {
+    return MAX_ITERATIONS;
+  }
+  // ── Private ────────────────────────────────────────────────────────────
+  getSessionSummary() {
+    const parts = [`Debug session complete.`];
+    if (this.hypothesis) {
+      parts.push(`Final hypothesis: "${this.hypothesis}"`);
+    }
+    parts.push(`Total iterations: ${this.iteration}`);
+    if (this.observations.length > 0) {
+      parts.push("Observations:");
+      for (const obs of this.observations) {
+        const verdict = obs.confirmsHypothesis ? "\u2713" : "\u2717";
+        parts.push(`  ${verdict} [iter ${obs.iteration}] ${obs.description}`);
+      }
+    }
+    const supporting = this.observations.filter((o) => o.confirmsHypothesis).length;
+    const contradicting = this.observations.length - supporting;
+    parts.push(`Evidence: ${supporting} supporting, ${contradicting} contradicting`);
+    if (this.conclusion) {
+      parts.push(`Conclusion: ${this.conclusion}`);
+    }
+    return parts.join("\n");
+  }
+  reset() {
+    this.hypothesis = null;
+    this.iteration = 0;
+    this.observations = [];
+    this._active = false;
+    this.conclusion = null;
   }
 };
+
+// src/setup/config.ts
+import { readFile } from "fs/promises";
+import { join } from "path";
+var DEVCONTAINER_PATH = ".devcontainer/conveyor/devcontainer.json";
+async function loadForwardPorts(workspaceDir) {
+  try {
+    const raw = await readFile(join(workspaceDir, DEVCONTAINER_PATH), "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed.forwardPorts ?? [];
+  } catch {
+    return [];
+  }
+}
+function loadConveyorConfig() {
+  const envSetup = process.env.CONVEYOR_SETUP_COMMAND;
+  const envStart = process.env.CONVEYOR_START_COMMAND;
+  const envPort = process.env.CONVEYOR_PREVIEW_PORT;
+  if (envSetup || envStart) {
+    return {
+      setupCommand: envSetup,
+      startCommand: envStart,
+      previewPort: envPort ? Number(envPort) : void 0
+    };
+  }
+  return null;
+}
+
+// src/setup/codespace.ts
+import { execSync as execSync2 } from "child_process";
+function unshallowRepo(workspaceDir) {
+  try {
+    execSync2("git fetch --unshallow", {
+      cwd: workspaceDir,
+      timeout: 6e4,
+      stdio: "ignore"
+    });
+  } catch {
+  }
+}
 export {
-  AgentRunner,
-  CdpDebugClient,
-  ConveyorConnection,
+  AgentConnection,
+  CommitWatcher,
+  DEFAULT_LIFECYCLE_CONFIG,
   DebugLifecycleManager,
   DebugManager,
   FileCache,
+  HypothesisTracker,
+  Lifecycle,
+  ModeController,
+  PlanSync,
   ProjectConnection,
   ProjectRunner,
+  SessionRunner,
+  detachWorktreeBranch,
+  detectRuntime,
   ensureWorktree,
+  getCurrentBranch,
+  hasUncommittedChanges,
+  hasUnpushedCommits,
+  injectBunInspectFlag,
   loadConveyorConfig,
+  loadForwardPorts,
+  pushToOrigin,
   removeWorktree,
+  runAuthTokenCommand,
   runSetupCommand,
-  runStartCommand
+  runStartCommand,
+  stageAndCommit,
+  unshallowRepo,
+  updateRemoteToken
 };
 //# sourceMappingURL=index.js.map