gutterpress 0.0.0

package/dist/cli-5bxx0c4y.js

@@ -0,0 +1,464 @@
+import {
+  capabilitiesFor,
+  detectProjectSource,
+  findEnclosingRepoDir
+} from "./cli-1tyj4bk3.js";
+
+// src/lib/source-provider.ts
+import * as fs from "node:fs";
+import path2 from "node:path";
+import git from "isomorphic-git";
+
+// src/lib/remote-auth/operation-log.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+var noop = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+function createFileLogger(logFile, operation, minLevel = "debug") {
+  try {
+    mkdirSync(path.dirname(logFile), { recursive: true });
+  } catch {
+    return noop;
+  }
+  function write(level, step, message, data) {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[minLevel])
+      return;
+    const ts = new Date().toISOString();
+    const fields = formatData(data);
+    const line = `[${ts}] ${level.toUpperCase().padEnd(5)} ${operation}: step=${step}${fields} | ${message}
+`;
+    try {
+      appendFileSync(logFile, line, "utf8");
+    } catch {}
+  }
+  return {
+    debug: (step, message, data) => write("debug", step, message, data),
+    info: (step, message, data) => write("info", step, message, data),
+    warn: (step, message, data) => write("warn", step, message, data),
+    error: (step, message, data) => write("error", step, message, data)
+  };
+}
+function resolveLogger(logFile, operation) {
+  if (!logFile)
+    return noop;
+  return createFileLogger(logFile, operation);
+}
+function formatData(data) {
+  if (!data)
+    return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (value === undefined)
+      continue;
+    if (Array.isArray(value)) {
+      parts.push(`${key}=${value.join(",")}`);
+    } else {
+      parts.push(`${key}=${String(value)}`);
+    }
+  }
+  return parts.length > 0 ? " " + parts.join(" ") : "";
+}
+function shortOid(oid) {
+  return oid.length >= 7 ? oid.slice(0, 7) : oid;
+}
+
+// src/lib/source-provider.ts
+var noopLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+function gitScopeFor(source) {
+  return source.repoRoot || source.path;
+}
+var HISTORY_PAGE_LIMIT = 100;
+var DEFAULT_AUTHOR = "gutterpress";
+var DEFAULT_EMAIL = "noreply@gutterpress.local";
+var DEFAULT_BRANCH = "main";
+var SNAPSHOT_STAGING_MARKER = "gutterpress-snapshot-staging";
+var repoQueues = new Map;
+function repoLockKey(projectDir) {
+  const resolved = path2.resolve(projectDir);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function withRepoLock(projectDir, fn) {
+  const key = repoLockKey(projectDir);
+  const prev = repoQueues.get(key) ?? Promise.resolve();
+  const run = prev.then(fn, fn);
+  const tail = run.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  repoQueues.set(key, tail);
+  tail.then(() => {
+    if (repoQueues.get(key) === tail)
+      repoQueues.delete(key);
+  });
+  return run;
+}
+function __repoLockQueueSizeForTests() {
+  return repoQueues.size;
+}
+function gitAuthor(name, email) {
+  const n = (name ?? "").trim();
+  const e = (email ?? "").trim();
+  return { name: n || DEFAULT_AUTHOR, email: e || DEFAULT_EMAIL };
+}
+async function readGitAuthor(dir) {
+  const [name, email] = await Promise.all([
+    git.getConfig({ fs, dir, path: "user.name" }).catch(() => {
+      return;
+    }),
+    git.getConfig({ fs, dir, path: "user.email" }).catch(() => {
+      return;
+    })
+  ]);
+  return {
+    name: typeof name === "string" ? name : undefined,
+    email: typeof email === "string" ? email : undefined
+  };
+}
+async function resolveGitAuthor(dir, name, email) {
+  const existing = await readGitAuthor(dir);
+  return gitAuthor(name || existing.name, email || existing.email);
+}
+async function listWorkdirChanges(dir, cache = {}) {
+  const adds = [];
+  const removes = [];
+  await git.walk({
+    fs,
+    dir,
+    cache,
+    trees: [git.WORKDIR(), git.STAGE()],
+    map: async (filepath, [workdir, stage]) => {
+      if (filepath === ".")
+        return;
+      if (!stage && workdir && await git.isIgnored({ fs, dir, filepath })) {
+        return null;
+      }
+      const [wType, sType] = await Promise.all([
+        workdir ? workdir.type() : Promise.resolve(undefined),
+        stage ? stage.type() : Promise.resolve(undefined)
+      ]);
+      if (wType === "tree" || sType === "tree") {
+        if (sType === "blob")
+          removes.push(filepath);
+        else if (wType === "blob")
+          adds.push(filepath);
+        return;
+      }
+      if (wType === "blob" && !sType) {
+        adds.push(filepath);
+      } else if (!wType && sType === "blob") {
+        removes.push(filepath);
+      } else if (wType === "blob" && sType === "blob") {
+        const workdirOid = await workdir.oid();
+        const stageOid = await stage.oid();
+        if (workdirOid !== stageOid) {
+          adds.push(filepath);
+        } else {
+          const fileBytes = await fs.promises.readFile(path2.join(dir, filepath));
+          const { oid: actualOid } = await git.hashBlob({ object: fileBytes });
+          if (actualOid !== stageOid)
+            adds.push(filepath);
+        }
+      }
+      return;
+    }
+  });
+  return { adds, removes };
+}
+async function stageChanges(dir, changes, cache) {
+  if (changes.adds.length > 0) {
+    await git.add({ fs, dir, cache, filepath: changes.adds });
+  }
+  for (const filepath of changes.removes) {
+    await git.remove({ fs, dir, cache, filepath });
+  }
+}
+async function hasPendingChanges(dir, cache = {}) {
+  const { adds, removes } = await listWorkdirChanges(dir, cache);
+  return adds.length > 0 || removes.length > 0;
+}
+async function hasUncommittedChanges(dir, cache = {}) {
+  if (await hasPendingChanges(dir, cache))
+    return true;
+  return !await stageMatchesHead(dir, cache);
+}
+async function stageMatchesHead(dir, cache) {
+  let headOid;
+  try {
+    headOid = await git.resolveRef({ fs, dir, ref: "HEAD" });
+  } catch {
+    return false;
+  }
+  let differs = false;
+  await git.walk({
+    fs,
+    dir,
+    cache,
+    trees: [git.TREE({ ref: headOid }), git.STAGE()],
+    map: async (filepath, [tree, stage]) => {
+      if (differs || filepath === ".")
+        return differs ? null : undefined;
+      const [tType, sType] = await Promise.all([
+        tree ? tree.type() : Promise.resolve(undefined),
+        stage ? stage.type() : Promise.resolve(undefined)
+      ]);
+      if (tType === "tree" || sType === "tree")
+        return;
+      if (!tType !== !sType) {
+        differs = true;
+        return null;
+      }
+      if (!tType || !sType)
+        return;
+      const [tOid, sOid] = await Promise.all([tree.oid(), stage.oid()]);
+      if (tOid !== sOid)
+        differs = true;
+      return null;
+    }
+  });
+  return !differs;
+}
+
+class LocalFolderSourceProvider {
+  source;
+  capabilities;
+  constructor(source) {
+    this.source = source;
+    this.capabilities = capabilitiesFor(source);
+  }
+  async initVersionHistory(options) {
+    const dir = options.projectDir;
+    if (await findEnclosingRepoDir(dir) !== undefined) {
+      throw new Error("This folder is already inside a versioned project, so gutterpress " + "won't create a separate history here.");
+    }
+    return withRepoLock(dir, async () => {
+      const cache = {};
+      await git.init({ fs, dir, defaultBranch: DEFAULT_BRANCH });
+      await stageChanges(dir, await listWorkdirChanges(dir, cache), cache);
+      await git.commit({
+        fs,
+        dir,
+        cache,
+        message: options.initialMessage?.trim() || "Created project",
+        author: await resolveGitAuthor(dir, options.authorName, options.authorEmail)
+      });
+      return {
+        type: "local-git-folder",
+        path: dir,
+        repoRoot: dir,
+        subPath: "",
+        hasRemote: false,
+        branch: DEFAULT_BRANCH
+      };
+    });
+  }
+  snapshot() {
+    return Promise.reject(new Error("This project has no version history yet. Enable version history first."));
+  }
+  listHistory() {
+    return Promise.resolve([]);
+  }
+  listHistoryPage() {
+    return Promise.resolve({ entries: [], hasMore: false });
+  }
+  restore() {
+    return Promise.reject(new Error("This project has no version history yet. Enable version history first."));
+  }
+}
+
+class LocalGitSourceProvider {
+  source;
+  capabilities;
+  dir;
+  constructor(source) {
+    this.source = source;
+    this.capabilities = capabilitiesFor(source);
+    this.dir = gitScopeFor(source);
+  }
+  async initVersionHistory(options) {
+    try {
+      await this.snapshot({
+        projectDir: options.projectDir,
+        message: options.initialMessage?.trim() || "Created project",
+        authorName: options.authorName,
+        authorEmail: options.authorEmail
+      });
+    } catch (e) {
+      if (!isNoChangesError(e))
+        throw e;
+    }
+    return this.source;
+  }
+  snapshot(options) {
+    return withRepoLock(this.dir, () => this.snapshotUnlocked(options));
+  }
+  snapshotUnlocked(options) {
+    return snapshotWorkingTreeUnlocked({ ...options, repoRoot: this.dir });
+  }
+  async listHistory(projectDir) {
+    return (await this.listHistoryPage(projectDir)).entries;
+  }
+  async listHistoryPage(_projectDir, options = {}) {
+    const dir = this.dir;
+    const limit = Math.min(500, Math.max(1, options.limit ?? HISTORY_PAGE_LIMIT));
+    const before = options.before;
+    let commits;
+    try {
+      commits = await git.log({
+        fs,
+        dir,
+        cache: {},
+        depth: limit + 2,
+        ...before ? { ref: before } : {}
+      });
+    } catch (e) {
+      if (before && e?.code === "NotFoundError") {
+        return { entries: [], hasMore: false };
+      }
+      throw e;
+    }
+    const seen = new Set;
+    let filtered = commits.filter((c) => {
+      if (c.oid === before || seen.has(c.oid))
+        return false;
+      seen.add(c.oid);
+      return true;
+    });
+    const hasMore = filtered.length > limit;
+    if (hasMore)
+      filtered = filtered.slice(0, limit);
+    return {
+      entries: filtered.map((c) => ({
+        id: c.oid,
+        message: c.commit.message.trim(),
+        timestamp: c.commit.author.timestamp * 1000,
+        author: c.commit.author.name
+      })),
+      hasMore
+    };
+  }
+  restore(options) {
+    return withRepoLock(this.dir, () => this.restoreUnlocked(options));
+  }
+  async restoreUnlocked(options) {
+    await git.checkout({
+      fs,
+      dir: this.dir,
+      cache: {},
+      ref: options.id,
+      force: true,
+      noUpdateHead: true
+    });
+  }
+}
+async function snapshotWorkingTreeUnlocked(options) {
+  const dir = options.repoRoot ?? options.projectDir;
+  const logger = options.logFile ? createFileLogger(options.logFile, "snapshot") : noopLogger;
+  const cache = {};
+  const stagingMarker = snapshotStagingMarkerPath(dir);
+  const staleStaging = fs.existsSync(stagingMarker);
+  const changes = await listWorkdirChanges(dir, cache);
+  const workdirClean = changes.adds.length === 0 && changes.removes.length === 0;
+  if (workdirClean && !staleStaging) {
+    logger.debug("snapshot", "no changes — skipping");
+    throw new Error("No changes since the last snapshot — there is nothing new to save.");
+  }
+  if (workdirClean && staleStaging && await stageMatchesHead(dir, cache)) {
+    logger.debug("snapshot", "stale marker outlived a completed commit — clearing, not recommitting");
+    fs.rmSync(stagingMarker, { force: true });
+    const [head2] = await git.log({ fs, dir, cache, depth: 1 });
+    return {
+      id: head2.oid,
+      message: head2.commit.message.trim(),
+      timestamp: head2.commit.author.timestamp * 1000,
+      author: head2.commit.author.name
+    };
+  }
+  logger.info("snapshot", "committing", {
+    adds: changes.adds.length,
+    removes: changes.removes.length,
+    ...staleStaging ? { recoveredStaleStaging: true } : {}
+  });
+  fs.writeFileSync(stagingMarker, "");
+  await stageChanges(dir, changes, cache);
+  const author = await resolveGitAuthor(dir, options.authorName, options.authorEmail);
+  const id = await git.commit({
+    fs,
+    dir,
+    cache,
+    message: options.message,
+    author
+  });
+  fs.rmSync(stagingMarker, { force: true });
+  const [head] = await git.log({ fs, dir, cache, depth: 1 });
+  return {
+    id,
+    message: options.message,
+    timestamp: head ? head.commit.author.timestamp * 1000 : Date.now(),
+    author: author.name
+  };
+}
+function isNoChangesError(e) {
+  return e instanceof Error && /no changes since the last snapshot/i.test(e.message);
+}
+function providerFor(source) {
+  switch (source.type) {
+    case "local-folder":
+      return new LocalFolderSourceProvider(source);
+    case "local-git-folder":
+      return new LocalGitSourceProvider(source);
+    case "managed-github":
+      throw new Error("Managed GitHub projects are not supported yet (#15/#16).");
+  }
+}
+function gitDirFor(projectDir) {
+  return path2.join(projectDir, ".git");
+}
+function snapshotStagingMarkerPath(projectDir) {
+  return path2.join(gitDirFor(projectDir), SNAPSHOT_STAGING_MARKER);
+}
+var RESTORE_BACKUP_MESSAGE = "Automatic backup before restoring an earlier version";
+var AUTO_SNAPSHOT_MESSAGE = "Automatic snapshot";
+async function restoreVersionWithBackup(options) {
+  const { projectDir, id, authorName, authorEmail } = options;
+  const source = await detectProjectSource(projectDir);
+  if (source.type !== "local-git-folder") {
+    throw new Error("This project has no version history yet. Enable version history first.");
+  }
+  const provider = new LocalGitSourceProvider(source);
+  const repoDir = gitScopeFor(source);
+  return withRepoLock(repoDir, async () => {
+    let backupId;
+    if (await hasPendingChanges(repoDir)) {
+      const backup = await provider.snapshotUnlocked({
+        projectDir,
+        message: RESTORE_BACKUP_MESSAGE,
+        authorName,
+        authorEmail
+      });
+      backupId = backup.id;
+    }
+    try {
+      await provider.restoreUnlocked({ projectDir, id });
+    } catch (cause) {
+      throw new Error(backupId ? "The restore could not be completed, but your work is safe — it was " + `automatically saved as a backup snapshot (${backupId.slice(0, 7)}) ` + "and appears in your version history." : "The restore could not be completed. Your project files were not changed.", { cause });
+    }
+    return { restoredId: id, backupId };
+  });
+}
+
+export { resolveLogger, shortOid, gitScopeFor, HISTORY_PAGE_LIMIT, SNAPSHOT_STAGING_MARKER, withRepoLock, __repoLockQueueSizeForTests, gitAuthor, readGitAuthor, resolveGitAuthor, listWorkdirChanges, stageChanges, hasPendingChanges, hasUncommittedChanges, snapshotWorkingTreeUnlocked, isNoChangesError, providerFor, gitDirFor, snapshotStagingMarkerPath, RESTORE_BACKUP_MESSAGE, AUTO_SNAPSHOT_MESSAGE, restoreVersionWithBackup };