acdev 1.0.0

package/src/store.js

@@ -0,0 +1,135 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { dataDir } from './paths.js';
+
+const IN_FLIGHT_STATUSES = new Set([
+  'syncing',
+  'preparing_worktree',
+  'running',
+  'applying_feedback',
+]);
+
+export class Store {
+  /** @param {string} repoRoot */
+  constructor(repoRoot) {
+    this.repoRoot = repoRoot;
+    this.statePath = path.join(dataDir(repoRoot), 'state.json');
+    this._ensureStateFile();
+    this.state = this._read();
+  }
+
+  _ensureStateFile() {
+    const dir = path.dirname(this.statePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    if (!fs.existsSync(this.statePath)) {
+      fs.writeFileSync(this.statePath, JSON.stringify({ jobs: [] }, null, 2) + '\n', 'utf8');
+    }
+  }
+
+  _read() {
+    return JSON.parse(fs.readFileSync(this.statePath, 'utf8'));
+  }
+
+  _write() {
+    fs.writeFileSync(this.statePath, JSON.stringify(this.state, null, 2) + '\n', 'utf8');
+  }
+
+  /** @returns {Job[]} */
+  getJobs() {
+    return [...this.state.jobs].sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+  }
+
+  /** @param {string} id @returns {Job | undefined} */
+  getJob(id) {
+    return this.state.jobs.find((j) => j.id === id);
+  }
+
+  /**
+   * @param {{
+   *   issueUrl: string,
+   *   issueNumber?: number,
+   *   ticketSource?: 'github' | 'jira',
+   *   jiraKey?: string,
+   * }} data
+   * @returns {Job}
+   */
+  addJob(data) {
+    const now = new Date().toISOString();
+    const ticketSource = data.ticketSource === 'jira' ? 'jira' : 'github';
+    /** @type {Job} */
+    const job = {
+      id: randomUUID(),
+      issueUrl: data.issueUrl,
+      issueNumber: data.issueNumber,
+      ticketSource,
+      ...(data.jiraKey ? { jiraKey: data.jiraKey } : {}),
+      status: 'queued',
+      createdAt: now,
+      updatedAt: now,
+      logs: [],
+    };
+    this.state.jobs.push(job);
+    this._write();
+    return job;
+  }
+
+  /**
+   * @param {string} id
+   * @param {Partial<Job>} patch
+   * @returns {Job}
+   */
+  updateJob(id, patch) {
+    const idx = this.state.jobs.findIndex((j) => j.id === id);
+    if (idx === -1) {
+      throw new Error(`Job not found: ${id}`);
+    }
+    const updated = {
+      ...this.state.jobs[idx],
+      ...patch,
+      updatedAt: new Date().toISOString(),
+    };
+    this.state.jobs[idx] = updated;
+    this._write();
+    return updated;
+  }
+
+  /**
+   * Remove a job from the store entirely (allows re-enqueue after dedupe).
+   * @param {string} id
+   * @returns {boolean} true if a job was removed
+   */
+  deleteJob(id) {
+    const idx = this.state.jobs.findIndex((j) => j.id === id);
+    if (idx === -1) return false;
+    this.state.jobs.splice(idx, 1);
+    this._write();
+    return true;
+  }
+
+  /** Mark in-flight jobs as failed after a server restart. */
+  reconcileStaleJobs() {
+    let changed = false;
+    for (const job of this.state.jobs) {
+      if (IN_FLIGHT_STATUSES.has(job.status)) {
+        job.status = 'failed';
+        job.error =
+          'Server restarted while this job was in progress. Re-queue this issue to retry.';
+        job.updatedAt = new Date().toISOString();
+        job.logs.push({
+          ts: new Date().toISOString(),
+          type: 'error',
+          payload: job.error,
+        });
+        changed = true;
+      }
+    }
+    if (changed) {
+      this._write();
+    }
+  }
+}

package/src/urls.js

@@ -0,0 +1,16 @@
+/**
+ * Split issue URL input on commas and/or newlines.
+ * Accepts a string, an array of strings, or nested mixes.
+ * @param {unknown} input
+ * @returns {string[]}
+ */
+export function splitIssueUrls(input) {
+  if (Array.isArray(input)) {
+    return input.flatMap((item) => splitIssueUrls(item));
+  }
+  if (typeof input !== 'string') return [];
+  return input
+    .split(/[\n,]+/)
+    .map((u) => u.trim())
+    .filter(Boolean);
+}

package/src/usage.js

@@ -0,0 +1,122 @@
+/**
+ * Normalize Claude Agent SDK result cost/usage into a first-class Job.usage shape.
+ *
+ * SDK result messages use snake_case on `usage` and camelCase on `modelUsage`.
+ *
+ * @typedef {object} JobUsage
+ * @property {number} [totalCostUsd]
+ * @property {number} [inputTokens]
+ * @property {number} [outputTokens]
+ * @property {number} [cacheReadInputTokens]
+ * @property {number} [cacheCreationInputTokens]
+ * @property {number} [numTurns]
+ * @property {number} [durationMs]
+ * @property {Record<string, object>} [modelUsage]
+ */
+
+/**
+ * @param {unknown} n
+ * @returns {number | undefined}
+ */
+function asFiniteNumber(n) {
+  if (typeof n !== 'number' || !Number.isFinite(n)) return undefined;
+  return n;
+}
+
+/**
+ * Extract usage from an SDK `result` message (success or error subtypes).
+ * @param {object | null | undefined} message
+ * @returns {JobUsage | null}
+ */
+export function extractUsageFromResult(message) {
+  if (!message || message.type !== 'result') return null;
+
+  const rawUsage = message.usage && typeof message.usage === 'object' ? message.usage : {};
+  const totalCostUsd = asFiniteNumber(message.total_cost_usd);
+  const inputTokens = asFiniteNumber(rawUsage.input_tokens);
+  const outputTokens = asFiniteNumber(rawUsage.output_tokens);
+  const cacheReadInputTokens = asFiniteNumber(rawUsage.cache_read_input_tokens);
+  const cacheCreationInputTokens = asFiniteNumber(rawUsage.cache_creation_input_tokens);
+  const numTurns = asFiniteNumber(message.num_turns);
+  const durationMs = asFiniteNumber(message.duration_ms);
+
+  let modelUsage;
+  if (message.modelUsage && typeof message.modelUsage === 'object') {
+    modelUsage = message.modelUsage;
+  }
+
+  const hasSignal =
+    totalCostUsd !== undefined ||
+    inputTokens !== undefined ||
+    outputTokens !== undefined ||
+    cacheReadInputTokens !== undefined ||
+    cacheCreationInputTokens !== undefined ||
+    modelUsage !== undefined;
+
+  if (!hasSignal) return null;
+
+  /** @type {JobUsage} */
+  const out = {};
+  if (totalCostUsd !== undefined) out.totalCostUsd = totalCostUsd;
+  if (inputTokens !== undefined) out.inputTokens = inputTokens;
+  if (outputTokens !== undefined) out.outputTokens = outputTokens;
+  if (cacheReadInputTokens !== undefined) out.cacheReadInputTokens = cacheReadInputTokens;
+  if (cacheCreationInputTokens !== undefined) {
+    out.cacheCreationInputTokens = cacheCreationInputTokens;
+  }
+  if (numTurns !== undefined) out.numTurns = numTurns;
+  if (durationMs !== undefined) out.durationMs = durationMs;
+  if (modelUsage !== undefined) out.modelUsage = modelUsage;
+  return out;
+}
+
+/**
+ * Scan job logs for the last `agent_event` whose payload is a `result` message
+ * that carries usage/cost fields. Used to backfill older jobs.
+ *
+ * Results that appear before the most recent `retry queued` status event are
+ * ignored so a prior run's cost does not leak onto a new attempt.
+ * @param {Array<{ type?: string, payload?: object }> | null | undefined} logs
+ * @returns {JobUsage | null}
+ */
+export function usageFromLogs(logs) {
+  if (!Array.isArray(logs)) return null;
+  let start = 0;
+  for (let i = 0; i < logs.length; i++) {
+    const ev = logs[i];
+    if (ev?.type === 'status' && ev.payload === 'retry queued') {
+      start = i + 1;
+    }
+  }
+  for (let i = logs.length - 1; i >= start; i--) {
+    const ev = logs[i];
+    if (ev?.type !== 'agent_event') continue;
+    const usage = extractUsageFromResult(ev.payload);
+    if (usage) return usage;
+  }
+  return null;
+}
+
+/**
+ * Ensure a job object exposes `usage` when it can be derived from logs.
+ * Does not mutate the stored job.
+ *
+ * Skips log backfill for queued / in-flight jobs so a retry does not keep
+ * showing the previous run's cost until the new run finishes.
+ * @param {object} job
+ * @returns {object}
+ */
+export function withJobUsage(job) {
+  if (!job || typeof job !== 'object') return job;
+  if (job.usage) return job;
+  const live = new Set([
+    'queued',
+    'syncing',
+    'preparing_worktree',
+    'running',
+    'applying_feedback',
+  ]);
+  if (live.has(job.status)) return job;
+  const usage = usageFromLogs(job.logs);
+  return usage ? { ...job, usage } : job;
+}