dsh-retrace 0.3.0 → 0.4.2

package/lib/versioning.js

@@ -19,10 +19,12 @@ import { join } from 'node:path'
 import { resolveDshHome } from '@deepseek-ai/dsh-home-paths'
 import {
   createArtifactStore,
+  gcArtifacts,
   refFor,
   retraceDomainSpec,
 } from './artifact-store.js'
 import { versionsProjectionDefinition } from './projection/versions.js'
+import { createGitAdapter, createSubprocessRunner } from './git-adapter.js'
 
 /** Max bytes snapshotted per touched file (over → file skipped, version kept). */
 const MAX_SNAPSHOT_BYTES = 4 * 1024 * 1024
@@ -30,7 +32,7 @@ const MAX_SNAPSHOT_BYTES = 4 * 1024 * 1024
 const BINARY_PROBE_BYTES = 1024
 
 /** Default per-session config (client may override per request). */
-export const DEFAULT_RETRACE_CONFIG = { versioning: true, git: true, retentionLimit: 50 }
+export const DEFAULT_RETRACE_CONFIG = { versioning: true, git: true, retentionLimit: 50, prewrite: true }
 
 function isBinary(bytes) {
   const probe = bytes.subarray(0, BINARY_PROBE_BYTES)
@@ -50,6 +52,7 @@ export function createVersioningSeam(ctx, log = () => {}, options = {}) {
   let seamCtx = null
   let domain = null
   let store = null
+  let git = null
   const disposers = []
   /** Per-session request-carried config; seeded from the domain global when ready. */
   const configs = new Map()
@@ -105,6 +108,109 @@ export function createVersioningSeam(ctx, log = () => {}, options = {}) {
     )
   }
 
+  /**
+   * Side effect: record the git facts (HEAD + dirty) of a new version boundary
+   * (PLAN §4.4 commit-free). Read-only commands only; best-effort — a failure
+   * just leaves the version without git facts (snapshot rollback still works).
+   */
+  async function recordVersionGit(session, record) {
+    if (!domain || !git || !configFor(session.id).git) return
+    const cwd = session.header?.cwd
+    if (typeof cwd !== 'string' || cwd.length === 0) return
+    try {
+      const status = await git.status(cwd)
+      await domain.table('versiongit').put(record.versionId, {
+        headHash: status?.headHash ?? null,
+        dirty: status?.dirty ?? false,
+      })
+    } catch (error) {
+      log(`retrace: git facts skipped for ${record.versionId}: ${String(error)}`)
+    }
+  }
+
+  /** The git adapter, created lazily once the seam context is available. */
+  function ensureGit() {
+    if (git === null && seamCtx !== null) {
+      // `ctx.subprocess` is a cordis getter that throws when the service is not
+      // injected; headless/minimal compositions degrade to snapshot-only
+      // rollback instead of crashing the plugin.
+      let subprocess
+      try {
+        subprocess = ctx.subprocess
+      } catch {
+        subprocess = undefined
+      }
+      if (subprocess) git = createGitAdapter(createSubprocessRunner(ctx, log))
+    }
+    return git
+  }
+
+  // -------------------------------------------------------------------------
+  // P1.5 — bounded retention: background GC over the artifact store.
+  // -------------------------------------------------------------------------
+  /** sessionId → retained versionIds (updated at every boundary we observe). */
+  const retainedVersions = new Map()
+  /** Throttle: one sweep per session at most every GC_INTERVAL_MS. */
+  const lastGc = new Map()
+  const GC_INTERVAL_MS = options.gcIntervalMs ?? 60_000
+
+  function noteRetained(sessionId, versions) {
+    retainedVersions.set(sessionId, new Set(versions.map((v) => v.versionId)))
+  }
+
+  /**
+   * Filter a refcounts record to the references still retained by any known
+   * session, returning the surviving refs. Unknown versions are kept
+   * (conservative — a cold-restored session we have not seen yet may still
+   * reference them).
+   */
+  function retainedRefs(refs) {
+    const retained = new Set()
+    for (const ids of retainedVersions.values()) for (const id of ids) retained.add(id)
+    return refs.filter((ref) => {
+      const colon = ref.indexOf(':')
+      const versionId = colon === -1 ? ref : ref.slice(0, colon)
+      return retained.has(versionId)
+    })
+  }
+
+  /**
+   * Throttled sweep: prune refs to truncated versions of known sessions, drop
+   * objects that end up with zero refs, and prune versiongit rows of versions
+   * no longer retained. Safe by construction — never touches an object a
+   * retained version references, and unknown sessions keep their refs.
+   */
+  async function sweepGc(sessionId) {
+    if (!domain || !store) return
+    const now = Date.now()
+    const last = lastGc.get(sessionId) ?? 0
+    if (now - last < GC_INTERVAL_MS) return
+    lastGc.set(sessionId, now)
+    try {
+      const refcounts = domain.table('refcounts')
+      const versiongit = domain.table('versiongit')
+      const keep = new Set()
+      const dead = []
+      for (const [sha, record] of refcounts.entries()) {
+        const refs = Array.isArray(record.refs) ? record.refs : []
+        const kept = retainedRefs(refs)
+        if (kept.length !== refs.length) await refcounts.put(sha, { ...record, refs: kept })
+        if (kept.length > 0) keep.add(sha)
+        else dead.push(sha)
+      }
+      // Prune versiongit rows of versions no session retains any more.
+      const retained = new Set()
+      for (const ids of retainedVersions.values()) for (const id of ids) retained.add(id)
+      for (const versionId of [...versiongit.keys()]) {
+        if (!retained.has(versionId)) await versiongit.delete(versionId)
+      }
+      const removed = await gcArtifacts(store, keep)
+      if (removed > 0 || dead.length > 0) log(`retrace: GC removed ${removed} objects (${dead.length} zero-ref)`)
+    } catch (error) {
+      log(`retrace: GC sweep failed: ${String(error)}`)
+    }
+  }
+
   /**
    * Register the projection unit, open the domain and wire the change feed.
    * Idempotent; safe to call from apply.
@@ -118,9 +224,12 @@ export function createVersioningSeam(ctx, log = () => {}, options = {}) {
       disposers.push(
         seam.sessionProjections.onChanged((session, key, value, seq) => {
           if (key !== 'retrace/versions') return
+          noteRetained(session.id, value.versions ?? [])
           const latest = value.versions.at(-1)
           if (!latest || latest.boundarySeq !== seq) return // only NEW boundaries
           void snapshotVersionFiles(session, latest)
+          void recordVersionGit(session, latest)
+          void sweepGc(session.id)
         }),
       )
       // Domain open is async; versioning degrades to L1 if it fails.
@@ -181,6 +290,77 @@ export function createVersioningSeam(ctx, log = () => {}, options = {}) {
     return seamCtx.sessionQuery.readSurface(sessionId)
   }
 
+  /** The live agent for one session (rollback busy-guard). */
+  function agentOf(sessionId) {
+    return ctx.agents?.get?.(sessionId) ?? undefined
+  }
+
+  /** Resolve the content address of `<versionId>:<path>` (or null). */
+  async function resolveSnapshot(versionId, path) {
+    if (!domain || !store) return null
+    const ref = refFor(versionId, path)
+    const refcounts = domain.table('refcounts')
+    for (const [sha, record] of refcounts.entries()) {
+      if (record.refs && record.refs.includes(ref)) return sha
+    }
+    return null
+  }
+
+  /** Integrity-checked snapshot read (rollback restore path). */
+  async function readSnapshot(sha) {
+    if (!store) {
+      const error = new Error('versioning surface unavailable')
+      error.code = 'versioning-unavailable'
+      throw error
+    }
+    return store.read(sha)
+  }
+
+  /** Git facts for one version (headHash recorded at its boundary). */
+  async function gitHeadFor(versionId) {
+    if (!domain) return null
+    return domain.table('versiongit').get(versionId) ?? null
+  }
+
+  /** Repo status of the session workspace (null = not a repository). */
+  async function gitStatus(sessionId) {
+    const adapter = ensureGit()
+    if (!adapter) return null
+    const session = ctx.sessions.get(sessionId)
+    const cwd = session?.header?.cwd
+    if (typeof cwd !== 'string' || cwd.length === 0) return null
+    return adapter.status(cwd)
+  }
+
+  /** `git checkout <headHash> -- <paths>` (write; caller confirms first). */
+  async function gitCheckout(cwd, headHash, paths) {
+    const adapter = ensureGit()
+    if (!adapter) {
+      const error = new Error('git adapter unavailable')
+      error.code = 'versioning-unavailable'
+      throw error
+    }
+    return adapter.checkout(cwd, headHash, paths)
+  }
+
+  /** One-click init for a non-repository workspace (write; caller confirms). */
+  async function gitInit(sessionId) {
+    const adapter = ensureGit()
+    if (!adapter) {
+      const error = new Error('git adapter unavailable')
+      error.code = 'versioning-unavailable'
+      throw error
+    }
+    const session = ctx.sessions.get(sessionId)
+    const cwd = session?.header?.cwd
+    if (typeof cwd !== 'string' || cwd.length === 0) {
+      const error = new Error('session has no workspace cwd')
+      error.code = 'no-cwd'
+      throw error
+    }
+    return adapter.init(cwd)
+  }
+
   return {
     register,
     available,
@@ -189,5 +369,12 @@ export function createVersioningSeam(ctx, log = () => {}, options = {}) {
     snapshot,
     readEvent,
     readSurface,
+    agentOf,
+    resolveSnapshot,
+    readSnapshot,
+    gitHeadFor,
+    gitStatus,
+    gitCheckout,
+    gitInit,
   }
 }

package/package.json

@@ -1,10 +1,17 @@
 {
   "name": "dsh-retrace",
   "description": "Retrace · 回溯 — Recall, edit-and-resend, regenerate, and conversation/artifact versioning (timeline, rollback, fork map) for DeepSeek Harness — Web and Desktop",
-  "version": "0.3.0",
+  "version": "0.4.2",
+  "packageManager": "pnpm@11.7.0",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
+  "scripts": {
+    "build": "node scripts/generate-dynamic.mjs && node scripts/build-client.mjs",
+    "check": "node scripts/check-syntax.mjs && node scripts/check-dynamic.mjs",
+    "test": "vitest run",
+    "prepublishOnly": "pnpm check && pnpm build && pnpm test"
+  },
   "exports": {
     ".": {
       "default": "./lib/index.js"
@@ -78,23 +85,19 @@
     "react": "^18.2.0"
   },
   "dependencies": {
+    "dsh-log-contract": "^0.1.0",
     "zod": "^4.4.3"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/azmavethy/dsh-retrace.git"
+    "url": "git+https://github.com/yamingmou/dsh-retrace.git"
   },
   "bugs": {
-    "url": "https://github.com/azmavethy/dsh-retrace/issues"
+    "url": "https://github.com/yamingmou/dsh-retrace/issues"
   },
-  "homepage": "https://github.com/azmavethy/dsh-retrace#readme",
+  "homepage": "https://github.com/yamingmou/dsh-retrace#readme",
   "devDependencies": {
     "esbuild": "^0.28.2",
     "vitest": "^4.1.11"
-  },
-  "scripts": {
-    "build": "node scripts/generate-dynamic.mjs && node scripts/build-client.mjs",
-    "check": "node scripts/check-syntax.mjs && node scripts/check-dynamic.mjs",
-    "test": "vitest run"
   }
-}
+}