@almadar/workspace 0.8.0 → 0.10.0

package/dist/__tests__/git-snapshots.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -10,6 +10,6 @@ export { openWorkspace } from './open-workspace.js';
 export { listWorkspaces } from './list-workspaces.js';
 export { deleteWorkspace } from './delete-workspace.js';
 export { openAccount } from './account.js';
-export type { WorkspaceService, WorkspaceObserver, WorkspaceWriteEvent, WorkspaceWatchEvent, OpenWorkspaceOptions, ListWorkspacesOptions, WorkspaceSummary, RestoreBackend, GitHubConfig, GitStatusInfo, FileTreeNode, AccountService, AccountConfig, ProviderCredential, AuthToken, AccountIdentity, OpenAccountOptions, } from './types.js';
+export type { WorkspaceService, WorkspaceObserver, WorkspaceWriteEvent, WorkspaceWatchEvent, OpenWorkspaceOptions, ListWorkspacesOptions, WorkspaceSummary, RestoreBackend, GitHubConfig, GitStatusInfo, SnapshotMeta, WorkspaceArchiveBackend, FileTreeNode, AccountService, AccountConfig, ProviderCredential, AuthToken, AccountIdentity, OpenAccountOptions, } from './types.js';
 export type { WorkspaceIndex, EmbedderPort, ResolveResult, ResolveOptions, TraitRefEmit, WorkspaceIndexStats, OrbitalIndexEntry, ExtraTraitIdentity, RetrievalResult, RetrievalOptions, RecentlyEditedOptions, EventEdge, EntityBinding, RuleBinding, RecencyEntry, IntentMaps, ComposedMaps, BM25Document, BM25Table, BM25Options, WorkspaceIndexManifest, } from './workspace-index/types.js';
 export { DEFAULT_COERCION_THRESHOLD, DEFAULT_RETRIEVAL_TOP_K, RRF_K, WORKSPACE_INDEX_SCHEMA_VERSION, } from './workspace-index/types.js';

package/dist/index.js

@@ -21,6 +21,13 @@ var LocalBackend = class {
     fs.mkdirSync(path2.dirname(absPath), { recursive: true });
     fs.writeFileSync(absPath, content, "utf-8");
   }
+  async readFileBytes(absPath) {
+    return fs.promises.readFile(absPath);
+  }
+  async writeFileBytes(absPath, bytes) {
+    await fs.promises.mkdir(path2.dirname(absPath), { recursive: true });
+    await fs.promises.writeFile(absPath, bytes);
+  }
   exists(absPath) {
     return fs.existsSync(absPath);
   }
@@ -77,6 +84,7 @@ var LocalBackend = class {
 var MemoryBackend = class {
   constructor() {
     this.files = /* @__PURE__ */ new Map();
+    this.bytes = /* @__PURE__ */ new Map();
     this.dirs = /* @__PURE__ */ new Set();
   }
   async readFile(absPath) {
@@ -93,6 +101,14 @@ var MemoryBackend = class {
   writeFileSync(absPath, content) {
     this.files.set(absPath, content);
   }
+  async readFileBytes(absPath) {
+    const b = this.bytes.get(absPath);
+    if (b === void 0) throw new Error(`ENOENT: ${absPath}`);
+    return b;
+  }
+  async writeFileBytes(absPath, bytes) {
+    this.bytes.set(absPath, bytes);
+  }
   exists(absPath) {
     if (this.files.has(absPath) || this.dirs.has(absPath)) return true;
     const prefix = absPath.endsWith("/") ? absPath : absPath + "/";
@@ -364,6 +380,7 @@ function createProjectOrbTemplate(projectName, appId) {
 function serializeJson(value) {
   return JSON.stringify(value, null, 2);
 }
+var GIT_BINARY = process.env.ALMADAR_GIT_BINARY || "git";
 var GitClient = class {
   constructor(cwd, backend) {
     this.cwd = cwd;
@@ -384,13 +401,12 @@ var GitClient = class {
   }
   async commit(message) {
     try {
-      const out = await this.exec(["commit", "-m", message, "--allow-empty-message"]);
-      const match = out.match(/\[[\w/.-]+ ([a-f0-9]+)\]/);
-      return match ? match[1] : null;
+      await this.exec(["commit", "-m", message, "--allow-empty-message"]);
     } catch (err) {
       if (err instanceof Error && err.message.includes("nothing to commit")) return null;
       throw err;
     }
+    return this.headSha();
   }
   async tag(name, message) {
     const args = ["tag"];
@@ -446,13 +462,51 @@ var GitClient = class {
       return null;
     }
   }
+  /**
+   * Commit history of `filepath` (newest first) — the snapshot list. NUL-delimited
+   * fields so commit subjects with tabs/spaces parse cleanly.
+   */
+  async log(filepath, limit) {
+    const args = ["log", "--format=%H%x00%at%x00%s"];
+    if (limit !== void 0) args.push("-n", String(limit));
+    if (filepath) args.push("--", filepath);
+    let out;
+    try {
+      out = await this.exec(args);
+    } catch {
+      return [];
+    }
+    const entries = [];
+    for (const line of out.split("\n")) {
+      if (!line) continue;
+      const [oid, ts, subject] = line.split("\0");
+      if (oid && ts) entries.push({ oid, timestamp: Number(ts) * 1e3, subject: subject ?? "" });
+    }
+    return entries;
+  }
+  /** Content of `filepath` at commit `oid` — the restore read. Null if absent. */
+  async show(oid, filepath) {
+    try {
+      return await this.exec(["show", `${oid}:${filepath}`]);
+    } catch {
+      return null;
+    }
+  }
+  /** Bundle the whole repo into a single delta-compressed file (the durable archive). */
+  async bundleAll(outAbsPath) {
+    await this.exec(["bundle", "create", outAbsPath, "--all"]);
+  }
+  /** Clone a bundle file into `targetDir` (hydrate a fresh workspace from the archive). */
+  async cloneBundle(bundleAbsPath, targetDir) {
+    await execGit(["clone", bundleAbsPath, targetDir], path2.dirname(bundleAbsPath));
+  }
   exec(args) {
     return execGit(args, this.cwd);
   }
 };
 function execGit(args, cwd) {
   return new Promise((resolve, reject) => {
-    execFile("git", args, { cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+    execFile(GIT_BINARY, args, { cwd, maxBuffer: 64 * 1024 * 1024 }, (err, stdout, stderr) => {
       if (err) {
         const message = stderr?.trim() || stdout?.trim() || err.message;
         reject(new Error(`git ${args[0]}: ${message}`));
@@ -491,9 +545,25 @@ async function writeMintTemplatesIfMissing(backend, workDir, userId, projectName
     );
   }
 }
+var GITIGNORE = [
+  "# Almadar \u2014 version only the app; ignore generated/churny state",
+  "/.almadar/sessions/",
+  "/.almadar/trace.jsonl",
+  "/.almadar/index.json",
+  "/.almadar/snapshots/",
+  "/.almadar/changesets/",
+  "/.almadar/history-meta.json",
+  "/apps/",
+  "/.almadar-archive.bundle",
+  ""
+].join("\n");
 async function ensureGitInit(backend, workDir) {
   const git = new GitClient(workDir, backend);
   await git.init();
+  const gitignorePath = path2.join(workDir, ".gitignore");
+  if (!backend.exists(gitignorePath)) {
+    await backend.writeFile(gitignorePath, GITIGNORE);
+  }
   return git;
 }
 function readAppMarker(backend, workDir) {
@@ -1700,6 +1770,7 @@ var WorkspaceServiceImpl = class {
     this._appId = args.appId;
     this.git = args.git;
     this.github = args.github;
+    this.archiveBackend = args.archiveBackend;
     this.index = new WorkspaceIndexImpl({
       workDir: this.workDir,
       backend: this.backend,
@@ -1718,6 +1789,14 @@ var WorkspaceServiceImpl = class {
   setAppId(id) {
     this._appId = id;
   }
+  /**
+   * Set (or clear) the GitHub config after open. Lets a consumer resolve the
+   * link/token lazily — e.g. from a workspace file read post-open — and wire
+   * `commitAndPush`/`pullIfLinked` without knowing it at construction time.
+   */
+  setGitHub(config) {
+    this.github = config;
+  }
   // === Helpers ===
   /** Run `op` under a per-path serial lock. */
   withLock(absPath, op) {
@@ -2089,6 +2168,55 @@ var WorkspaceServiceImpl = class {
     const linked = await this.git.hasRemote("origin");
     return { ...s, linked };
   }
+  // === Snapshots (git history of schema.orb) ===
+  async snapshot(reason) {
+    if (!this.git) return null;
+    await this.git.addAll();
+    const oid = await this.git.commit(`snapshot: ${reason}`);
+    return oid ? { oid } : null;
+  }
+  async listSnapshots(opts) {
+    if (!this.git) return [];
+    const entries = await this.git.log(WORKSPACE_LAYOUT.SCHEMA_FILE, opts?.limit);
+    return entries.map((e) => ({
+      id: e.oid,
+      timestamp: e.timestamp,
+      reason: e.subject.startsWith("snapshot: ") ? e.subject.slice("snapshot: ".length) : e.subject
+    }));
+  }
+  async restore(oid) {
+    if (!this.git) return null;
+    return this.git.show(oid, WORKSPACE_LAYOUT.SCHEMA_FILE);
+  }
+  async archive() {
+    if (!this.git || !this.archiveBackend) return;
+    const bundlePath = path2.join(this.workDir, ".almadar-archive.bundle");
+    await this.git.bundleAll(bundlePath);
+    const bytes = await this.backend.readFileBytes(bundlePath);
+    await this.archiveBackend.saveBundle(bytes);
+    await this.backend.rm(bundlePath).catch(() => {
+    });
+  }
+  async hydrateFromArchive() {
+    if (!this.git || !this.archiveBackend) return false;
+    const bytes = await this.archiveBackend.loadBundle();
+    if (!bytes) return false;
+    const base = path2.basename(this.workDir);
+    const bundlePath = path2.join(path2.dirname(this.workDir), `${base}.bundle`);
+    const cloneDir = path2.join(path2.dirname(this.workDir), `${base}.hydrate`);
+    await this.backend.writeFileBytes(bundlePath, bytes);
+    try {
+      await this.backend.rm(cloneDir, { recursive: true }).catch(() => {
+      });
+      await this.git.cloneBundle(bundlePath, cloneDir);
+      await this.backend.rm(this.workDir, { recursive: true });
+      await this.backend.rename(cloneDir, this.workDir);
+      return true;
+    } finally {
+      await this.backend.rm(bundlePath).catch(() => {
+      });
+    }
+  }
   // === Observation ===
   subscribe(observer) {
     return this.sinks.subscribe(observer);
@@ -2244,7 +2372,7 @@ async function openWorkspaceInternal(opts) {
     }
   }
   let git;
-  if (!bare && opts.github && opts.backend !== "memory") {
+  if (!bare && opts.backend !== "memory") {
     git = await ensureGitInit(backend, resolved.workDir);
   }
   const service = new WorkspaceServiceImpl({
@@ -2254,7 +2382,8 @@ async function openWorkspaceInternal(opts) {
     embedder: opts.embedder ?? createDefaultEmbedder(),
     appId: resolved.appId,
     git,
-    github: opts.github
+    github: opts.github,
+    archiveBackend: opts.archiveBackend
   });
   if (!bare) {
     await service.index.warm();