@anionex/dsh-turn-rewind 0.2.2 → 0.3.0

package/src/validate.ts

@@ -102,7 +102,8 @@ export function parseManifest(value: unknown): RestorePointManifest {
   }
   if (version === LEDGER_FORMAT_VERSION) return { version, ...common }
   if (restorePointKind !== 'turn') corrupt('Git-native v2 restore points are automatic turn checkpoints')
-  return { version, ...common, git: parseGitCheckpoint(record.git, id) }
+  if (repository.type !== 'git') corrupt('Git-native v2 restore points must fence a Git workspace')
+  return { version, ...common, repository, git: parseGitCheckpoint(record.git, id) }
 }
 
 /** Parse an untrusted durable restore-operation journal. */
@@ -158,9 +159,27 @@ export function validateBlobHash(value: string): string {
   return value
 }
 
+/**
+ * Parse the durable workspace fence of one manifest.
+ *
+ * A missing `type` is the only legacy interpretation: manifests written before
+ * ordinary-directory support are always Git workspaces and are upgraded in
+ * memory. Directory fences must not carry Git-only fields.
+ * @param value - persisted `repository` field.
+ * @returns the validated workspace state.
+ */
 function parseRepository(value: unknown): RepositoryState {
   const record = objectRecord(value, 'repository state')
   const root = absoluteString(record, 'root')
+  if (record.type === 'directory') {
+    for (const key of ['commonDir', 'head', 'branch', 'operation', 'stagedPaths']) {
+      if (record[key] !== undefined) corrupt(`directory workspace state must not contain ${key}`)
+    }
+    return { type: 'directory', root }
+  }
+  if (record.type !== undefined && record.type !== 'git') {
+    corrupt('workspace state type must be "git" or "directory"')
+  }
   const commonDir = absoluteString(record, 'commonDir')
   const head = optionalHash(record, 'head')
   const branch = optionalString(record, 'branch')
@@ -169,6 +188,7 @@ function parseRepository(value: unknown): RepositoryState {
   if (!Array.isArray(stagedValue)) corrupt('repository stagedPaths must be an array')
   const stagedPaths = stagedValue.map((path) => validateRelativePath(requireString(path, 'staged path')))
   return {
+    type: 'git',
     root,
     commonDir,
     ...(head === undefined ? {} : { head }),

package/src/workspace.ts

@@ -0,0 +1,66 @@
+import { discoverDirectory, discoverDirectoryRoot, type DirectorySnapshotSource } from './directory.js'
+import {
+  discoverRepositoryOptional,
+  discoverRepositoryRootOptional,
+  sameRepositoryFence,
+  type RepositorySnapshotSource,
+} from './git.js'
+import type { ResolvedChangeLedgerConfig, WorkspaceState } from './types.js'
+
+/** Eligible snapshot source for either supported workspace mode. */
+export type WorkspaceSnapshotSource = RepositorySnapshotSource | DirectorySnapshotSource
+
+/**
+ * Discover the owning Git worktree, or treat `cwd` itself as an ordinary
+ * directory when it is not inside any repository.
+ * @param cwd - working directory the Session runs in.
+ * @param config - capture limits applied to ordinary-directory enumeration.
+ * @param signal - optional caller cancellation.
+ * @returns the snapshot source for the owning workspace.
+ */
+export async function discoverWorkspace(
+  cwd: string,
+  config: Pick<ResolvedChangeLedgerConfig, 'maxFiles' | 'maxFileBytes'>,
+  signal?: AbortSignal,
+): Promise<WorkspaceSnapshotSource> {
+  const repository = await discoverRepositoryOptional(cwd, signal)
+  return repository ?? discoverDirectory(cwd, config, signal)
+}
+
+/** Workspace mode and root resolved without inventorying any files. */
+export interface WorkspaceIdentity {
+  readonly type: WorkspaceState['type']
+  readonly root: string
+}
+
+/**
+ * Resolve the workspace mode and root without inventorying files, for callers
+ * that only need to address the workspace (locks, skip markers, storage purge).
+ * @param cwd - working directory the Session runs in.
+ * @param signal - optional caller cancellation.
+ * @returns the workspace mode and canonical root.
+ */
+export async function discoverWorkspaceIdentity(cwd: string, signal?: AbortSignal): Promise<WorkspaceIdentity> {
+  const root = await discoverRepositoryRootOptional(cwd, signal)
+  return root === undefined
+    ? { type: 'directory', root: await discoverDirectoryRoot(cwd) }
+    : { type: 'git', root }
+}
+
+/** Resolve the workspace root without inventorying its files. */
+export async function discoverWorkspaceRoot(cwd: string, signal?: AbortSignal): Promise<string> {
+  return (await discoverWorkspaceIdentity(cwd, signal)).root
+}
+
+/**
+ * Whether two fences still describe the same workspace.
+ *
+ * Git workspaces keep the full repository fence (HEAD, branch, operation);
+ * ordinary directories only own their canonical root, so a moved or recreated
+ * root is the only thing that can invalidate them.
+ */
+export function sameWorkspaceFence(left: WorkspaceState, right: WorkspaceState): boolean {
+  if (left.type !== right.type || left.root !== right.root) return false
+  if (left.type === 'directory' || right.type === 'directory') return true
+  return sameRepositoryFence(left, right)
+}