@supanadit/morse-web 0.7.0 → 0.8.0

package/dist/server.mjs

@@ -75,7 +75,7 @@ function hasKnownType(value, allowed) {
 }
 
 // ../protocol/dist/version.js
-var PROTOCOL_VERSION = 18;
+var PROTOCOL_VERSION = 19;
 var FRONTEND_MANIFEST_FILE = "webview.manifest.json";
 var DEFAULT_WS_PATH = "/ws";
 
@@ -3851,10 +3851,143 @@ function toPosix(path) {
   return path.split("\\").join("/");
 }
 
-// ../server/src/internal/workspace/workspace-index.ts
+// ../server/src/internal/workspace/git-log.ts
 import { execFile } from "node:child_process";
+import { relative as relative3 } from "node:path";
+var DEFAULT_MAX_COMMITS = 250;
+var HARD_MAX_COMMITS = 500;
+var FIELD = "";
+var RECORD = "";
+var PRETTY_FORMAT = ["%H", "%h", "%P", "%D", "%an", "%aI", "%s"].join(FIELD) + RECORD;
+async function readGitLog(cwd, requestedMax, requestedSkip) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, commits: [] };
+  }
+  const max = clampMax(requestedMax);
+  const skip = clampSkip(requestedSkip);
+  const [root, branch, raw] = await Promise.all([
+    gitText(["rev-parse", "--show-toplevel"], cwd),
+    gitText(["rev-parse", "--abbrev-ref", "HEAD"], cwd),
+    gitText(
+      [
+        "log",
+        "--all",
+        "--date-order",
+        `--skip=${skip}`,
+        `--max-count=${max}`,
+        `--pretty=format:${PRETTY_FORMAT}`
+      ],
+      cwd
+    )
+  ]);
+  return {
+    isRepo: true,
+    root: root?.trim() || cwd,
+    branch: branch?.trim() || void 0,
+    commits: parseCommits(raw ?? "")
+  };
+}
+function clampMax(requested) {
+  if (requested === void 0 || !Number.isFinite(requested)) {
+    return DEFAULT_MAX_COMMITS;
+  }
+  return Math.max(1, Math.min(HARD_MAX_COMMITS, Math.floor(requested)));
+}
+async function readGitStatus(cwd) {
+  const inside = await gitText(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (inside?.trim() !== "true") {
+    return { isRepo: false, files: [] };
+  }
+  const [prefix, raw] = await Promise.all([
+    gitText(["rev-parse", "--show-prefix"], cwd),
+    gitText(["status", "--porcelain=v1", "-z", "--untracked-files=all"], cwd)
+  ]);
+  return { isRepo: true, files: parseStatus(raw ?? "", prefix?.trim() ?? "") };
+}
+function parseStatus(raw, root) {
+  const records = raw.split("\0");
+  const files = [];
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record || record.length < 4) {
+      continue;
+    }
+    const status = record.slice(0, 2);
+    if (status[0] === "R" || status[0] === "C") {
+      index += 1;
+    }
+    const full = record.slice(3);
+    if (root.length > 0 && !full.startsWith(root)) {
+      continue;
+    }
+    const path = full.slice(root.length);
+    if (path.length > 0) {
+      files.push({ path: toPosix2(path), status });
+    }
+  }
+  return files;
+}
+async function readGitDiff(cwd, requested) {
+  const rel = toPosix2(relative3(cwd, resolveWithin(cwd, requested)));
+  const diff = await gitText(
+    ["diff", "--no-color", "--no-ext-diff", "-U3", "HEAD", "--", rel],
+    cwd
+  );
+  return { path: rel, diff: diff ?? "" };
+}
+function toPosix2(path) {
+  return path.split("\\").join("/");
+}
+function clampSkip(requested) {
+  if (requested === void 0 || !Number.isFinite(requested)) {
+    return 0;
+  }
+  return Math.max(0, Math.floor(requested));
+}
+function parseCommits(raw) {
+  const commits = [];
+  for (const record of raw.split(RECORD)) {
+    const line = record.replace(/^\n+/, "");
+    if (line.trim().length === 0) {
+      continue;
+    }
+    const fields = line.split(FIELD);
+    const [hash, shortHash, parents, refs, author, date, subject] = fields;
+    if (!hash || !shortHash || !date) {
+      continue;
+    }
+    commits.push({
+      hash,
+      shortHash,
+      parents: (parents ?? "").split(" ").filter((parent) => parent.length > 0),
+      refs: parseRefs(refs ?? ""),
+      author: author ?? "",
+      date,
+      subject: subject ?? ""
+    });
+  }
+  return commits;
+}
+function parseRefs(raw) {
+  const refs = raw.split(",").map((ref) => ref.trim()).filter((ref) => ref.length > 0);
+  return refs;
+}
+function gitText(args, cwd) {
+  return new Promise((resolve6) => {
+    execFile(
+      "git",
+      args,
+      { cwd, timeout: 5e3, maxBuffer: 16 * 1024 * 1024, windowsHide: true },
+      (error, stdout) => resolve6(error ? void 0 : stdout)
+    );
+  });
+}
+
+// ../server/src/internal/workspace/workspace-index.ts
+import { execFile as execFile2 } from "node:child_process";
 import { readdir as readdir4 } from "node:fs/promises";
-import { join as join7, relative as relative3 } from "node:path";
+import { join as join7, relative as relative4 } from "node:path";
 var SKIPPED_DIRECTORIES2 = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -3875,15 +4008,15 @@ var MAX_INDEXED_FILES = 5e3;
 var INDEX_TTL_MS = 6e4;
 var indexes = /* @__PURE__ */ new Map();
 var inFlight = /* @__PURE__ */ new Map();
-async function workspaceFiles(cwd, logger) {
-  const { files, source } = await cachedIndex(cwd);
+async function workspaceFiles(cwd, logger, options = {}) {
+  const { files, source } = await cachedIndex(cwd, options.fresh === true);
   logger.info(`File picker: ${files.length} entries via ${source} in ${cwd}`);
   return files;
 }
-async function cachedIndex(cwd) {
+async function cachedIndex(cwd, fresh) {
   const now = Date.now();
   const cached = indexes.get(cwd);
-  if (cached && now - cached.at < INDEX_TTL_MS) {
+  if (!fresh && cached && now - cached.at < INDEX_TTL_MS) {
     return cached;
   }
   const pending = inFlight.get(cwd);
@@ -3939,7 +4072,7 @@ async function gitFileList(cwd) {
 }
 function runGit(args, cwd) {
   return new Promise((resolve6) => {
-    execFile(
+    execFile2(
       "git",
       args,
       { cwd, timeout: 5e3, maxBuffer: 8 * 1024 * 1024, windowsHide: true },
@@ -3974,11 +4107,11 @@ async function walk(root, directory, files) {
       continue;
     }
     if (entry.isFile() || entry.isSymbolicLink()) {
-      files.push(toPosix2(relative3(root, full)));
+      files.push(toPosix3(relative4(root, full)));
     }
   }
 }
-function toPosix2(path) {
+function toPosix3(path) {
   return path.split("\\").join("/");
 }
 
@@ -4008,6 +4141,9 @@ var MorseSessionFactory = class {
       // A browser has no editor of its own, so this host reads files for the
       // frontend's Explorer and preview tabs. VS Code keeps its native ones.
       filePreview: true,
+      // The same reasoning for history: VS Code has Source Control, so the
+      // browser host is the one that answers `gitLog` for its own git panel.
+      gitPanel: true,
       // A browser cannot hand a dragged file's path to pi, so the host takes the
       // bytes and writes them next to the session; the frontend then `@mentions`
       // the path it gets back.
@@ -4071,7 +4207,7 @@ var MorseSessionFactory = class {
       }
       case "listFiles": {
         const cwd = this.requireWritableCwd(context);
-        const files = await workspaceFiles(cwd, this.logger);
+        const files = await workspaceFiles(cwd, this.logger, { fresh: args?.fresh === true });
         return { files };
       }
       case "readFile": {
@@ -4088,6 +4224,24 @@ var MorseSessionFactory = class {
         this.logger.info(`Upload stored: ${saved.path} (${saved.bytes} bytes)`);
         return saved;
       }
+      case "gitLog": {
+        const cwd = this.requireWritableCwd(context);
+        const max = typeof args?.max === "number" ? args.max : void 0;
+        const skip = typeof args?.skip === "number" ? args.skip : void 0;
+        return readGitLog(cwd, max, skip);
+      }
+      case "gitStatus": {
+        const cwd = this.requireWritableCwd(context);
+        return readGitStatus(cwd);
+      }
+      case "gitDiff": {
+        const cwd = this.requireWritableCwd(context);
+        const path = typeof args?.path === "string" ? args.path : "";
+        if (path.length === 0) {
+          throw new UnsupportedByHostError('gitDiff needs a "path" argument.');
+        }
+        return readGitDiff(cwd, path);
+      }
       default:
         throw new UnsupportedByHostError(`This host does not support "${command}".`);
     }