agentbox-app 0.1.13 → 0.1.16

package/shared/agent-hours.mjs

@@ -0,0 +1,136 @@
+// AGENT HOURS: the level, the week, the streak (w-3d0fa23ffb).
+//
+// Pure. A run is `{key, at, start, item, product, engine, seconds, failed,
+// began}`: `at` is when it ended, and a run is counted on the local day it
+// ended. Every run whose agent actually began counts its wall time, failed or
+// not, and overlapping runs each count.
+
+export const MASTERY_HOURS = 10_000;
+const MAX_RUN_SECONDS = 24 * 3600;
+const DAY_MS = 86_400_000;
+
+// Up to 99, hours grow as level^2.5: level 2 in minutes, 99 at MASTERY_HOURS.
+// Not RuneScape's curve, which spends half its hours on the last seven levels
+// and so reads 82 after one heavy month. Past 99 there is no ceiling and each
+// level costs 5% more than the last, starting from the curve's pace at 99 so
+// no level ever costs less than the one before.
+const RISE = 2.5;
+const PAST = Math.log(1.05);
+const PACE_AT_99 = (MASTERY_HOURS * RISE) / 98;
+// A level starts at its exact hours, not one float step later.
+const EPS = 1e-10;
+
+export function hoursForLevel(level) {
+  const L = Number(level);
+  if (!(L > 1)) return 0;
+  if (L <= 99) return MASTERY_HOURS * ((L - 1) / 98) ** RISE;
+  return MASTERY_HOURS + (PACE_AT_99 * Math.expm1((L - 99) * PAST)) / PAST;
+}
+
+export function levelFor(hours) {
+  const h = Number(hours);
+  if (!Number.isFinite(h) || h <= 0) return 1;
+  if (h < MASTERY_HOURS) return 1 + Math.floor(98 * (h / MASTERY_HOURS) ** (1 / RISE) + EPS);
+  return 99 + Math.floor(Math.log1p(((h - MASTERY_HOURS) * PAST) / PACE_AT_99) / PAST + EPS);
+}
+
+const pad = (n) => String(n).padStart(2, '0');
+export const localDate = (ms) => { const d = new Date(ms); return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`; };
+const localMonth = (ms) => localDate(ms).slice(0, 7);
+
+function mondayOf(ms) {
+  const d = new Date(ms);
+  d.setHours(0, 0, 0, 0);
+  d.setDate(d.getDate() - ((d.getDay() + 6) % 7));
+  return d.getTime();
+}
+
+function startOfDay(ms) {
+  const d = new Date(ms);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+
+const counts = (r) => r && r.began !== false && Number.isFinite(r.at) && Number(r.seconds) > 0;
+
+// One line per key. The line written when the run ended beats one read back
+// from its log, which may have been read while the run was still going.
+export function dedupeRuns(runs) {
+  const seen = new Map();
+  for (const r of runs ?? []) {
+    if (!r || typeof r !== 'object' || typeof r.key !== 'string' || !r.key) continue;
+    if (!Number.isFinite(r.at) || !(Number(r.seconds) > 0)) continue;
+    const had = seen.get(r.key);
+    if (!had || (had.backfilled && !r.backfilled)) seen.set(r.key, r);
+  }
+  return [...seen.values()];
+}
+
+// Days in a row with a run, counted back from today, or from yesterday when
+// today has none yet. `dates` are local YYYY-MM-DD strings, from any number of
+// Macs.
+export function streakOf(dates, now = Date.now()) {
+  const have = new Set(dates);
+  let cursor = startOfDay(now);
+  if (!have.has(localDate(cursor))) cursor -= DAY_MS / 2;
+  let n = 0;
+  while (have.has(localDate(cursor))) {
+    n += 1;
+    // Half a day back and then to the start of that day survives a DST change.
+    cursor = startOfDay(startOfDay(cursor) - DAY_MS / 2);
+  }
+  return n;
+}
+
+export function summarizeRuns(runs, { now = Date.now() } = {}) {
+  const weekStartMs = mondayOf(now);
+  const dayStartMs = startOfDay(now);
+  let total = 0;
+  let week = 0;
+  let today = 0;
+  const active = new Set();
+  const months = new Map();
+  const first = new Date(now);
+  first.setDate(1);
+  for (let i = 11; i >= 0; i -= 1) {
+    const d = new Date(first.getFullYear(), first.getMonth() - i, 1);
+    months.set(`${d.getFullYear()}-${pad(d.getMonth() + 1)}`, 0);
+  }
+  for (const r of dedupeRuns(runs)) {
+    if (!counts(r) || r.at > now) continue;
+    const h = Math.min(Number(r.seconds), MAX_RUN_SECONDS) / 3600;
+    total += h;
+    if (r.at >= weekStartMs) week += h;
+    if (r.at >= dayStartMs) today += h;
+    active.add(localDate(r.at));
+    const m = localMonth(r.at);
+    if (months.has(m)) months.set(m, months.get(m) + h);
+  }
+  const activeDays = [...active].sort().slice(-60);
+  return {
+    total,
+    week,
+    weekStart: localDate(weekStartMs),
+    today,
+    day: localDate(dayStartMs),
+    streak: streakOf(activeDays, now),
+    activeDays,
+    byMonth: [...months].map(([month, hours]) => ({ month, hours })),
+    level: levelFor(total),
+  };
+}
+
+// One run read back from its trace log, `sessions/<item>/<startedAtMs>.log`:
+// the start is the file's name, the end the `# exited (code) <ISO>` footer,
+// else the file's last write.
+export function runFromTrace({ name, text = '', mtimeMs, item, product }) {
+  const m = /^(\d{12,14})\.log$/.exec(String(name ?? ''));
+  if (!m) return null;
+  const start = Number(m[1]);
+  const footer = /# exited \((-?\d+|null)\) (\S+)(?: · [^\n]*)?\s*$/m.exec(String(text));
+  const end = footer ? Date.parse(footer[2]) : Number(mtimeMs);
+  if (!Number.isFinite(end) || end <= start) return null;
+  const seconds = Math.round((end - start) / 1000);
+  if (seconds > MAX_RUN_SECONDS) return null;
+  return { key: `${item}:${start}`, at: end, start, item, product, engine: null, seconds, failed: footer ? footer[1] !== '0' : null };
+}

package/shared/agent-import.mjs

@@ -18,7 +18,7 @@
 /**
  * The label every one of these rows carries, so a second walk through the
  *  first run can tell which agents already have a row and file nothing twice. */
-import { NAME, Name } from '../shared/product-name.mjs';
+import { NAME } from '../shared/product-name.mjs';
 export const IMPORT_LABEL = 'agent-import';
 
 /**
@@ -107,11 +107,11 @@ export function agentsNeedingRows(chosen, existingItems = []) {
 }
 
 /* --------------------------- AND THE THREADS ----------------------------- */
-// Of the three things a picked thread could do, this is the plainest one. It
-// does NOT resume the conversation, and that is the half these words have to
-// carry, because a row named after an earlier conversation is a row anybody
-// would assume was carrying it on. So the body says, in plain words, that this
-// starts fresh.
+// A picked thread becomes a row that carries the conversation on. It first
+// did not: the body said the reply started fresh, and somebody importing a
+// hundred half-finished sessions was asked to restate every one of them
+// (GitHub #44). The row is still only a row here; the resume happens on the
+// first reply, in `Supervisor#importedThreadFor`.
 //
 // Everything else is the agent import's shape, for the same reasons: one row per
 // thing the user ticked, a label so a second press files nothing twice, and a
@@ -125,6 +125,53 @@ export const THREAD_LABEL = 'thread-import';
  *  which is stable across renames and is what the transcript is filed under. */
 export const threadLabel = (id) => `thread:${String(id ?? '').trim()}`;
 
+/**
+ * WHETHER A CHAT ENDED WAITING ON YOU, read off the agent's last reply.
+ *
+ *  Waiting means the reply's last line is a question, or a question followed by
+ *  the choices it offers. `ask` is that question, cut from the front when it is
+ *  long, because the question is at the end of the line. */
+const ASK_CHARS = 140;
+const SHORT_ASK = 40;
+const CHOICE = /^(\d+[.)]|[-*+]|[a-z][.)])\s+/i;
+const NOT_WAITING = Object.freeze({ waiting: false, ask: '' });
+
+function plainLine(line) {
+  return String(line)
+    .replace(/^(>\s*)+/, '')
+    .replace(/^#{1,6}\s+/, '')
+    .replace(/[*`]+/g, '')
+    // An underscore between two letters is part of a name (account_id).
+    .replace(/(?<![A-Za-z0-9])_+|_+(?![A-Za-z0-9])/g, '')
+    .replace(/^[("'“‘\s]+/, '')
+    .replace(/[)"'”’\s]+$/, '')
+    .trim();
+}
+
+function shortAsk(line) {
+  if (line.length <= ASK_CHARS) return line;
+  const sentences = line.split(/(?<=[.!?])\s+/);
+  let last = sentences.pop();
+  // "Shall I do that?" says nothing without the sentence it follows.
+  while (last.length < SHORT_ASK && sentences.length && sentences.at(-1).length + 1 + last.length <= ASK_CHARS) {
+    last = `${sentences.pop()} ${last}`;
+  }
+  if (last.length <= ASK_CHARS) return last;
+  const tail = line.slice(-(ASK_CHARS - 1));
+  const sp = tail.indexOf(' ');
+  return `…${sp > 0 && sp < 40 ? tail.slice(sp + 1) : tail}`;
+}
+
+export function howTheChatEnded(said) {
+  const lines = String(said ?? '').replace(/\r/g, '').split('\n').map((l) => l.trim()).filter(Boolean);
+  let i = lines.length - 1;
+  while (i >= 0 && CHOICE.test(lines[i])) i -= 1;
+  if (i < 0) return { ...NOT_WAITING };
+  const line = plainLine(lines[i].replace(CHOICE, ''));
+  if (!line.endsWith('?')) return { ...NOT_WAITING };
+  return { waiting: true, ask: shortAsk(line) };
+}
+
 /**
  * WHEN SHE HAD IT, in the words a person uses about this week.
  *
@@ -154,37 +201,16 @@ export function startedIn(source) {
 }
 
 /**
- * ONE IMPORTED THREAD'S WORDS.
- *
- *  The title is the thread's own, which is the first thing the user typed into
- *  it, so the row in the inbox is called what they would call it. Ours is not
- *  added in front of it: a list of rows all opening with the same three words is
- *  a list that has to be read past to find which is which.
- *
- *  The last paragraph is the honest one. Agentbox read the top of the transcript
- *  to find this name and nothing else, and the reply starts a fresh session. A
- *  row that let her believe otherwise would be the same empty promise the agent
- *  import had before 08-23, in a new place. */
-export function threadImportRow(thread, { projectName = null, now = Date.now() } = {}) {
+ * ONE IMPORTED THREAD'S WORDS, the chat as it was: the title Claude Code gave
+ *  it, your first message as the body and the agent's last reply as the
+ *  result, so the thread opens on the question it ended with. The reply
+ *  carries the conversation on (`Supervisor#importedThreadFor`). */
+export function threadImportRow(thread) {
   const title = String(thread?.title || '').trim();
-  const where = String(thread?.short || thread?.folder || '').trim();
-  const when = whenWords(thread?.when, now);
-  const started = [
-    'You started this',
-    startedIn(thread?.source),
-    when,
-    where ? `in ${where}` : '',
-  ].filter(Boolean).join(' ');
-  const inProject = projectName ? ` here in ${projectName}` : '';
-  const body = [
-    '**Say what you want done next in this thread.**',
-    `${started}.`,
-    `Reply with the job and ${NAME} runs it${inProject}, answering you here.`,
-    `${Name} has not read the conversation, only the line above that names it, and replying starts a fresh session rather than carrying the old one on. So say what you need in the reply.`,
-  ].join('\n\n');
   return {
     title,
-    body,
+    body: String(thread?.firstSaid || '').trim() || title,
+    result: String(thread?.lastSaid || '').trim(),
     kind: 'question',
     priority: 3,
     labels: [THREAD_LABEL, threadLabel(thread?.id)],