opencode-global-habit-profile 0.0.0-stage → 0.2.0

package/src/plugin-stats.js

@@ -0,0 +1,215 @@
+import { statSync } from "node:fs"
+
+const hookNames = Object.freeze(["session.prompt", "session.context", "tool.execute.after", "shell.create.before"])
+const latencyBuckets = Object.freeze([1, 5, 10, 25, 50, 100, 250, 500, 1000, 5000])
+const histogram = () => ({ counts: new Array(latencyBuckets.length).fill(0) })
+let startedAt
+let hooks
+let context
+let store
+let sse
+let requests
+let flush
+let errors
+
+function reset() {
+  startedAt = Date.now()
+  hooks = Object.fromEntries(hookNames.map((name) => [name, { invocations: 0, errors: 0, latency: histogram() }]))
+  context = { injections: 0, injectedChars: 0, notices: { checkpoint: 0, todo: 0 } }
+  store = { reads: 0, writes: 0, bytesRead: 0, bytesWritten: 0, lockWaits: 0, lockTimeouts: 0, errors: 0, writeLatency: histogram() }
+  sse = { clients: 0, peakClients: 0, refreshes: 0 }
+  requests = { "2xx": 0, "4xx": 0, "5xx": 0 }
+  flush = { lastAt: null, pending: 0, failures: 0 }
+  errors = { hooks: 0, store: 0, server: 0, collector: 0 }
+}
+reset()
+
+function observe(histogramValue, durationMs) {
+  const value = Number(durationMs)
+  if (!Number.isFinite(value) || value < 0) return
+  let index = latencyBuckets.findIndex((max) => value <= max)
+  if (index === -1) index = latencyBuckets.length - 1
+  histogramValue.counts[index]++
+}
+
+function percentile(histogramValue, quantile) {
+  const samples = histogramValue.counts.reduce((sum, count) => sum + count, 0)
+  if (!samples) return null
+  const target = Math.ceil(samples * quantile)
+  let seen = 0
+  for (let index = 0; index < histogramValue.counts.length; index++) {
+    seen += histogramValue.counts[index]
+    if (seen >= target) return latencyBuckets[index]
+  }
+  return latencyBuckets.at(-1)
+}
+
+function histogramSnapshot(histogramValue) {
+  return {
+    samples: histogramValue.counts.reduce((sum, count) => sum + count, 0),
+    p50: percentile(histogramValue, 0.5),
+    p95: percentile(histogramValue, 0.95),
+    buckets: histogramValue.counts.map((count, index) => ({ maxMs: index === histogramValue.counts.length - 1 ? null : latencyBuckets[index], count })),
+  }
+}
+
+function recordHook(name, durationMs, failed) {
+  const hook = hooks[name]
+  if (!hook) return
+  hook.invocations++
+  observe(hook.latency, durationMs)
+  if (failed) {
+    hook.errors++
+    errors.hooks++
+  }
+}
+
+export async function measureHook(name, fn) {
+  const started = Date.now()
+  try {
+    const result = await fn()
+    recordHook(name, Date.now() - started, false)
+    return result
+  } catch (error) {
+    recordHook(name, Date.now() - started, true)
+    throw error
+  }
+}
+
+export function recordHookError(name) {
+  const hook = hooks[name]
+  if (!hook) return
+  hook.errors++
+  errors.hooks++
+}
+
+export function recordContextChars(chars) {
+  const value = Number(chars)
+  if (!Number.isSafeInteger(value) || value < 0) return
+  if (!value) return
+  context.injections++
+  context.injectedChars += value
+}
+
+export function recordNotice(kind) {
+  if (kind === "checkpoint" || kind === "todo") context.notices[kind]++
+}
+
+export function recordStoreRead(bytes) {
+  store.reads++
+  const value = Number(bytes)
+  if (Number.isSafeInteger(value) && value >= 0) store.bytesRead += value
+}
+
+export function recordStoreWrite(bytes, durationMs) {
+  store.writes++
+  const value = Number(bytes)
+  if (Number.isSafeInteger(value) && value >= 0) store.bytesWritten += value
+  observe(store.writeLatency, durationMs)
+}
+
+export function recordStoreLockWait() {
+  store.lockWaits++
+}
+
+export function recordStoreLockTimeout() {
+  store.lockTimeouts++
+  errors.store++
+}
+
+export function recordStoreError() {
+  store.errors++
+  errors.store++
+}
+
+export function recordSseClient(delta) {
+  sse.clients = Math.max(0, sse.clients + (Number(delta) || 0))
+  sse.peakClients = Math.max(sse.peakClients, sse.clients)
+}
+
+export function recordSseRefresh() {
+  sse.refreshes++
+}
+
+export function recordRequestStatus(status) {
+  const code = Number(status)
+  if (code >= 200 && code < 300) requests["2xx"]++
+  else if (code >= 400 && code < 500) requests["4xx"]++
+  else if (code >= 500 && code < 600) {
+    requests["5xx"]++
+    errors.server++
+  }
+}
+
+export function recordServerError() {
+  errors.server++
+}
+
+export function recordCollectorPending(pending) {
+  const value = Number(pending)
+  flush.pending = Number.isSafeInteger(value) && value >= 0 ? value : 0
+}
+
+export function recordCollectorFlush(pending, failed) {
+  flush.lastAt = Date.now()
+  recordCollectorPending(pending)
+  if (failed) {
+    flush.failures++
+    errors.collector++
+  }
+}
+
+function currentCounts(storeData) {
+  if (!storeData || typeof storeData !== "object") return null
+  const checkpoints = Array.isArray(storeData.checkpoints) ? storeData.checkpoints : []
+  const todos = Array.isArray(storeData.todos) ? storeData.todos : []
+  return {
+    checkpoints: checkpoints.length,
+    todos: todos.length,
+    activeTodos: todos.filter((todo) => todo?.status === "pending").length,
+    scopes: new Set(checkpoints.map((checkpoint) => `${checkpoint?.project}\u0000${checkpoint?.context}`)).size,
+  }
+}
+
+function fileSize(path) {
+  try { return statSync(path).size } catch { return null }
+}
+
+export function storeStats() {
+  return {
+    reads: store.reads,
+    writes: store.writes,
+    bytesRead: store.bytesRead,
+    bytesWritten: store.bytesWritten,
+    lockWaits: store.lockWaits,
+    lockTimeouts: store.lockTimeouts,
+    errors: store.errors,
+    writeLatency: histogramSnapshot(store.writeLatency),
+  }
+}
+
+export function pluginSnapshot({ storeData, storePath, metricsPath } = {}) {
+  return {
+    startedAt: new Date(startedAt).toISOString(),
+    uptimeMs: Math.max(0, Date.now() - startedAt),
+    hooks: Object.fromEntries(Object.entries(hooks).map(([name, hook]) => [name, {
+      invocations: hook.invocations,
+      errors: hook.errors,
+      latency: histogramSnapshot(hook.latency),
+    }])),
+    context: { injections: context.injections, injectedChars: context.injectedChars, notices: { ...context.notices } },
+    store: storeStats(),
+    sse: { clients: sse.clients, peakClients: sse.peakClients, refreshes: sse.refreshes },
+    requests: { ...requests },
+    flush: { ...flush },
+    errors: { ...errors },
+    current: currentCounts(storeData),
+    bytes: { store: fileSize(storePath), metrics: fileSize(metricsPath) },
+  }
+}
+
+export function resetPluginStats() {
+  reset()
+}
+
+export { hookNames }

package/src/store.js

@@ -0,0 +1,296 @@
+import { randomUUID } from "node:crypto"
+import { mkdir, open, readFile, rename, stat, unlink } from "node:fs/promises"
+import { dirname, join } from "node:path"
+import { homedir } from "node:os"
+import { recordStoreError, recordStoreLockTimeout, recordStoreLockWait, recordStoreRead, recordStoreWrite, storeStats } from "./plugin-stats.js"
+
+const maxBytes = 2_000_000
+const categories = new Set([
+  ...["bash", "read", "write", "edit", "patch", "glob", "grep", "task", "subagent", "websearch", "webfetch"].flatMap((n) => [`tool:${n}`, `request:tool:${n}`]),
+  ...["git", "php", "python", "python3", "pytest", "composer", "npm", "pnpm", "yarn", "bun", "docker", "opencode", "codesearch"].flatMap((n) => [`cli:${n}`, `request:cli:${n}`]),
+  ...["build", "plan", "code", "explore", "general", "orquestador", "01-debug", "02-agente-plan", "03-fix", "04-test", "agente-debugger", "cambio-quirurgico", "ciberseguridad", "django-expert", "docker", "docker-expert", "frontend-designer", "git", "investigador-cientifico", "investigador-secundario", "linux-expert", "minecraft", "versionador"].map((n) => `request:agent:${n}`),
+])
+const root = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share")
+export const storePath = join(root, "habit-memory-plugin", "store-v1.json")
+const lockPath = `${storePath}.lock`
+const recoveryPath = `${lockPath}.recovery`
+const staleLockMs = 120_000
+const sameFile = (a, b) => a.dev === b.dev && a.ino === b.ino
+async function unlinkIfSame(path, identity) {
+  try { if (sameFile(identity, await stat(path))) await unlink(path) } catch {}
+}
+async function hasRecoveryClaim() {
+  try { await stat(recoveryPath); return true } catch (error) {
+    if (error.code === "ENOENT") return false
+    throw error
+  }
+}
+async function lockSnapshot() { return { stat: await stat(lockPath), contents: await readFile(lockPath, "utf8") } }
+function sameLock(a, b) {
+  return sameFile(a.stat, b.stat) && a.stat.size === b.stat.size && a.stat.mtimeMs === b.stat.mtimeMs && a.stat.ctimeMs === b.stat.ctimeMs && a.contents === b.contents
+}
+async function recoverStaleLock() {
+  let initial
+  try {
+    initial = await lockSnapshot()
+    if (Date.now() - initial.stat.mtimeMs <= staleLockMs) return
+  } catch { return }
+  const pid = Number(initial.contents), validPid = Number.isSafeInteger(pid) && pid > 0
+  if (validPid) {
+    try { process.kill(pid, 0); return } catch (error) { if (error.code !== "ESRCH") return }
+  }
+  let claim
+  try { claim = await open(recoveryPath, "wx", 0o600) } catch { return }
+  try {
+    const before = await lockSnapshot()
+    if (!sameLock(initial, before) || Date.now() - before.stat.mtimeMs <= staleLockMs) return
+    if (validPid) {
+      try { process.kill(pid, 0); return } catch (error) { if (error.code !== "ESRCH") return }
+    }
+    const current = await lockSnapshot()
+    if (!sameLock(before, current) || Date.now() - current.stat.mtimeMs <= staleLockMs) return
+    if (validPid) {
+      try { process.kill(pid, 0); return } catch (error) { if (error.code !== "ESRCH") return }
+    }
+    await unlink(lockPath)
+  } catch {
+    // Any uncertainty leaves the existing lock in place.
+  } finally {
+    await claim.close().catch(() => {})
+    await unlink(recoveryPath).catch(() => {})
+  }
+}
+
+const empty = () => ({ version: 1, habits: { version: 1, counts: {}, daily: {} }, checkpoints: [], todos: [] })
+const text = (v, max = 240) => typeof v === "string" && v.length > 0 && v.length <= max
+const basenameValue = (v) => typeof v === "string" && v.length > 0 && v.length <= 128 && v === v.trim() && v !== "." && v !== ".." && !/[\\/\u0000-\u001f\u007f]/.test(v) ? v : undefined
+const validDate = (value) => /^\d{4}-\d{2}-\d{2}$/.test(value) && new Date(`${value}T00:00:00.000Z`).toISOString().slice(0, 10) === value
+function valid(data) {
+  if (!data || Object.keys(data).some((k) => !["version", "habits", "checkpoints", "todos"].includes(k)) || data.version !== 1 || !data.habits || Object.keys(data.habits).some((k) => !["version", "counts", "daily", "legacyImported"].includes(k)) || data.habits.version !== 1 || !data.habits.counts || (data.habits.legacyImported !== undefined && typeof data.habits.legacyImported !== "boolean") || !Array.isArray(data.checkpoints) || (data.todos !== undefined && !Array.isArray(data.todos))) throw new Error("Invalid habit-memory store schema")
+  for (const [key, count] of Object.entries(data.habits.counts)) if (!categories.has(key) || !Number.isSafeInteger(count) || count < 1 || count > 999) throw new Error("Invalid habits data")
+  const daily = data.habits.daily === undefined ? {} : data.habits.daily
+  if (!daily || typeof daily !== "object" || Array.isArray(daily) || Object.keys(daily).length > 365) throw new Error("Invalid daily habit data")
+  for (const [date, counts] of Object.entries(daily)) {
+    if (!validDate(date) || !counts || typeof counts !== "object" || Array.isArray(counts) || !Object.keys(counts).length) throw new Error("Invalid daily habit data")
+    for (const [key, count] of Object.entries(counts)) if (!categories.has(key) || !Number.isSafeInteger(count) || count < 1) throw new Error("Invalid daily habit data")
+  }
+  data.habits.daily = daily
+  if (data.checkpoints.length > 10000 || data.checkpoints.some((c) => !c || Object.keys(c).some((k) => !["id", "project", "context", "summary", "createdAt", "sessionTitle", "projectDirectoryName"].includes(k)) || !text(c.id, 80) || !text(c.project, 128) || !text(c.context, 128) || !text(c.summary) || !text(c.createdAt, 40) || (c.sessionTitle !== undefined && !text(c.sessionTitle, 200)) || (c.projectDirectoryName !== undefined && !basenameValue(c.projectDirectoryName)))) throw new Error("Invalid checkpoint data")
+  data.todos ??= []
+  if (data.todos.length > 10000 || data.todos.some((todo) => !todo || Object.keys(todo).some((k) => !["id", "project", "task", "status", "createdAt", "updatedAt", "projectDirectoryName"].includes(k)) || !text(todo.id, 80) || !text(todo.project, 128) || !text(todo.task) || todo.task !== todo.task.trim() || !["pending", "completed", "archived"].includes(todo.status) || !text(todo.createdAt, 40) || !text(todo.updatedAt, 40) || (todo.projectDirectoryName !== undefined && !basenameValue(todo.projectDirectoryName)))) throw new Error("Invalid TODO data")
+  return data
+}
+async function read() {
+  try {
+    const raw = await readFile(storePath)
+    recordStoreRead(raw.length)
+    if (raw.length > maxBytes) throw new Error("Storage exceeds size limit")
+    return valid(JSON.parse(raw))
+  } catch (error) {
+    if (error.code === "ENOENT") { recordStoreRead(0); return empty() }
+    recordStoreError()
+    throw error
+  }
+}
+async function locked(fn) {
+  await mkdir(dirname(storePath), { recursive: true, mode: 0o700 })
+  const deadline = Date.now() + 5000
+  let handle, identity
+  while (!handle) {
+    try {
+      const candidate = await open(lockPath, "wx", 0o600)
+      let candidateIdentity
+      try {
+        candidateIdentity = await candidate.stat()
+        if (await hasRecoveryClaim()) {
+          await candidate.close()
+          await unlinkIfSame(lockPath, candidateIdentity)
+        } else {
+          handle = candidate
+          identity = candidateIdentity
+        }
+      } catch (error) {
+        await candidate.close().catch(() => {})
+        if (candidateIdentity) await unlinkIfSame(lockPath, candidateIdentity)
+        throw error
+      }
+    }
+    catch (error) {
+      if (error.code !== "EEXIST") throw error
+      await recoverStaleLock()
+    }
+    if (!handle) {
+      if (Date.now() >= deadline) { recordStoreLockTimeout(); throw new Error("Storage is locked") }
+      recordStoreLockWait()
+      await new Promise((resolve) => setTimeout(resolve, 25))
+    }
+  }
+  try {
+    await handle.writeFile(String(process.pid))
+    return await fn()
+  } finally {
+    await handle.close()
+    await unlinkIfSame(lockPath, identity)
+  }
+}
+async function write(data) {
+  const started = Date.now()
+  try {
+    valid(data)
+    const serialized = JSON.stringify(data)
+    if (Buffer.byteLength(serialized) > maxBytes) throw new Error("Storage exceeds size limit")
+    const temp = `${storePath}.${process.pid}.${randomUUID()}.tmp`
+    const handle = await open(temp, "wx", 0o600)
+    try {
+      await handle.writeFile(serialized)
+      await handle.sync()
+      await handle.close()
+      await rename(temp, storePath)
+    } catch (error) {
+      await handle.close().catch(() => {})
+      await unlink(temp).catch(() => {})
+      throw error
+    }
+    recordStoreWrite(Buffer.byteLength(serialized), Date.now() - started)
+  } catch (error) {
+    recordStoreError()
+    throw error
+  }
+}
+const scope = (project, context) => {
+  if (!text(project, 128) || !text(context, 128)) throw new Error("project and context are required (max 128 chars)")
+}
+export async function getData() { return read() }
+export async function saveHabitCounts(counts) {
+  return locked(async () => { const data = await read(); data.habits = { ...data.habits, version: 1, counts }; await write(data) })
+}
+export async function incrementHabitCounts(keys) {
+  return locked(async () => {
+    const data = await read()
+    const accepted = [...new Set(keys.filter((key) => categories.has(key)))]
+    if (!accepted.length) return
+    const today = new Date().toISOString().slice(0, 10)
+    const cutoff = new Date(`${today}T00:00:00.000Z`)
+    cutoff.setUTCDate(cutoff.getUTCDate() - 364)
+    for (const date of Object.keys(data.habits.daily)) if (date < cutoff.toISOString().slice(0, 10) || date > today) delete data.habits.daily[date]
+    const daily = data.habits.daily[today] ??= {}
+    for (const key of accepted) {
+      data.habits.counts[key] = Math.min(999, (data.habits.counts[key] ?? 0) + 1)
+      daily[key] = Math.min(Number.MAX_SAFE_INTEGER, (daily[key] ?? 0) + 1)
+    }
+    await write(data)
+  })
+}
+export async function clearHabits() {
+  return locked(async () => {
+    const data = await read()
+    data.habits = { version: 1, counts: {}, daily: {}, ...(data.habits.legacyImported === undefined ? {} : { legacyImported: data.habits.legacyImported }) }
+    await write(data)
+  })
+}
+export async function saveCheckpoint(project, context, summary, sessionTitle, projectDirectoryName) {
+  scope(project, context)
+  if (!text(summary)) throw new Error("summary is required (max 240 chars)")
+  return locked(async () => {
+    const data = await read()
+    const title = typeof sessionTitle === "string" ? sessionTitle.trim() : ""
+    const directory = basenameValue(typeof projectDirectoryName === "string" ? projectDirectoryName.trim() : projectDirectoryName)
+    const record = { id: randomUUID(), project, context, summary, createdAt: new Date().toISOString(), ...(title && title.length <= 200 ? { sessionTitle: title } : {}), ...(directory ? { projectDirectoryName: directory } : {}) }
+    data.checkpoints.push(record)
+    await write(data); return record
+  })
+}
+export async function listCheckpoints(project, context) {
+  scope(project, context)
+  return (await read()).checkpoints.filter((c) => c.project === project && c.context === context).sort((a,b) => b.createdAt.localeCompare(a.createdAt))
+}
+export async function listCheckpointContexts(project) {
+  if (!text(project, 128)) throw new Error("project is required (max 128 chars)")
+  return [...new Set((await read()).checkpoints.filter((c) => c.project === project).map((c) => c.context))].sort()
+}
+export async function deleteCheckpoint(project, context, id) {
+  scope(project, context)
+  if (!text(id, 80)) throw new Error("id is required (max 80 chars)")
+  return locked(async () => { const data = await read(), before = data.checkpoints.length; data.checkpoints = data.checkpoints.filter((c) => !(c.project === project && c.context === context && c.id === id)); if (before !== data.checkpoints.length) await write(data); return before !== data.checkpoints.length })
+}
+export async function updateCheckpoint(project, context, id, summary) {
+  scope(project, context)
+  if (!text(id, 80) || !text(summary)) throw new Error("id and summary are required (max 240 chars)")
+  return locked(async () => {
+    const data = await read(), checkpoint = data.checkpoints.find((c) => c.project === project && c.context === context && c.id === id)
+    if (!checkpoint) return false
+    checkpoint.summary = summary
+    await write(data)
+    return true
+  })
+}
+export async function clearCheckpoints(project, context) {
+  scope(project, context)
+  return locked(async () => { const data = await read(), before = data.checkpoints.length; data.checkpoints = data.checkpoints.filter((c) => c.project !== project || c.context !== context); if (before !== data.checkpoints.length) await write(data); return before - data.checkpoints.length })
+}
+export async function createTodo(project, taskValue, directoryNameValue) {
+  if (!text(project, 128)) throw new Error("project is required (max 128 chars)")
+  const task = typeof taskValue === "string" ? taskValue.trim() : ""
+  if (!text(task)) throw new Error("task is required (max 240 chars)")
+  const directoryName = basenameValue(typeof directoryNameValue === "string" ? directoryNameValue.trim() : directoryNameValue)
+  return locked(async () => {
+    const data = await read()
+    if (data.todos.length >= 10000) throw new Error("TODO limit reached")
+    const now = new Date().toISOString()
+    const todo = { id: randomUUID(), project, task, status: "pending", createdAt: now, updatedAt: now, ...(directoryName ? { projectDirectoryName: directoryName } : {}) }
+    data.todos.push(todo)
+    await write(data)
+    return todo
+  })
+}
+export async function listTodos(project, includeArchived = false) {
+  if (!text(project, 128) || typeof includeArchived !== "boolean") throw new Error("project and a boolean archive filter are required")
+  return (await read()).todos.filter((todo) => todo.project === project && (includeArchived || todo.status !== "archived"))
+}
+export async function updateTodo(project, id, taskValue, status) {
+  if (!text(project, 128) || !text(id, 80)) throw new Error("project and id are required")
+  const task = taskValue === undefined ? undefined : typeof taskValue === "string" ? taskValue.trim() : ""
+  if ((task !== undefined && !text(task)) || (status !== undefined && !["pending", "completed"].includes(status)) || (task === undefined && status === undefined)) throw new Error("a non-empty task or pending/completed status is required")
+  return locked(async () => {
+    const data = await read(), todo = data.todos.find((item) => item.project === project && item.id === id && item.status !== "archived")
+    if (!todo) return false
+    if (task !== undefined) todo.task = task
+    if (status !== undefined) todo.status = status
+    todo.updatedAt = new Date().toISOString()
+    await write(data)
+    return true
+  })
+}
+export async function archiveTodo(project, id) {
+  if (!text(project, 128) || !text(id, 80)) throw new Error("project and id are required")
+  return locked(async () => {
+    const data = await read(), todo = data.todos.find((item) => item.project === project && item.id === id && item.status !== "archived")
+    if (!todo) return false
+    todo.status = "archived"
+    todo.updatedAt = new Date().toISOString()
+    await write(data)
+    return true
+  })
+}
+export function getStoreStats() {
+  return storeStats()
+}
+
+export async function importLegacy(profile, checkpoint) {
+  return locked(async () => {
+    const data = await read()
+    let changed = false
+    if (!data.habits.legacyImported) {
+      const counts = profile?.version === 1 && profile.counts
+        ? Object.fromEntries(Object.entries(profile.counts).filter(([k,v]) => categories.has(k) && Number.isSafeInteger(v) && v > 0).map(([k,v]) => [k, Math.min(v,999)]))
+        : data.habits.counts
+      data.habits = { ...data.habits, version: 1, counts, legacyImported: true }
+      changed = true
+    }
+    if (checkpoint?.version === 1 && text(checkpoint.summary) && text(checkpoint.project, 128) && !data.checkpoints.some((c) => c.id === `legacy-${checkpoint.project}`)) {
+      data.checkpoints.push({ id: `legacy-${checkpoint.project}`, project: checkpoint.project, context: "legacy", summary: checkpoint.summary, createdAt: new Date(0).toISOString() })
+      changed = true
+    }
+    if (changed) await write(data)
+  })
+}