hafez 2.1.0 → 2.3.0

package/dist/git.js

@@ -6,6 +6,49 @@ import { mergeVaultContent } from './merge.js';
 import { VAULT_FILE_RE, INDEXED_DIR_PATHSPECS, classifyIndexedRelPath, vaultKindFromRelPath } from './vault.js';
 import { normalizeSinceDate } from './dates.js';
 import { HafezError } from './types.js';
+// Hafez runs git in the user's own shell, and git inherited that environment before simple-git
+// guarded it. simple-git 4 guards it two ways, and both are opened in full: `allowEnvironment`
+// names every key the process carries (the guard otherwise strips ambient GIT_* / EDITOR / PAGER
+// keys and rejects supplied ones — a user's GIT_SSH_COMMAND or GIT_AUTHOR_* would vanish), and
+// `unsafe` opens every category — `Required`, so a category the library adds fails the build
+// instead of rejecting some user's shell at runtime (4.0 moved GIT_EXEC_PATH to allowUnsafeExec).
+const OPEN_UNSAFE = {
+    allowUnsafeAlias: true,
+    allowUnsafeAskPass: true,
+    allowUnsafeCommandBinaries: true,
+    allowUnsafeConfigEnvCount: true,
+    allowUnsafeConfigPaths: true,
+    allowUnsafeCredentialHelper: true,
+    allowUnsafeDiffExternal: true,
+    allowUnsafeDiffTextConv: true,
+    allowUnsafeEditor: true,
+    allowUnsafeExec: true,
+    allowUnsafeFilter: true,
+    allowUnsafeFsMonitor: true,
+    allowUnsafeGitProxy: true,
+    allowUnsafeGpgProgram: true,
+    allowUnsafeHooksPath: true,
+    allowUnsafeInclude: true,
+    allowUnsafeMergeDriver: true,
+    allowUnsafePack: true,
+    allowUnsafePager: true,
+    allowUnsafeProtocolOverride: true,
+    allowUnsafeSshCommand: true,
+    allowUnsafeSubmodule: true,
+    allowUnsafeTemplateDir: true,
+    allowUnsafeUrlRewrite: true,
+    allowUnsafeCustomBinary: true,
+    // Otherwise the plugin exports GIT_TEST_DISALLOW_ABBREVIATED_OPTIONS to the child and the
+    // vault's own hooks start failing on abbreviated long options only when hafez commits.
+    allowAbbreviatedOptions: true
+};
+// Hafez's own git calls are never interactive: GIT_EDITOR outranks core.editor, -c, VISUAL and
+// EDITOR. `.env()` replaces the child env, hence the spread.
+const vaultGit = (vaultPath) => simpleGit({
+    baseDir: vaultPath,
+    allowEnvironment: [...Object.keys(process.env), 'GIT_EDITOR'],
+    unsafe: OPEN_UNSAFE
+}).env({ ...process.env, GIT_EDITOR: 'true' });
 const logMerge = (msg) => process.stderr.write(`[hafez-merge] ${msg}\n`);
 const MAX_PUSH_RETRIES = 3;
 const RETRY_BASE_MS = 200;
@@ -279,7 +322,7 @@ async function pushResolving(git, vaultPath, conflictMessage, exhaustedMessage)
  * All work must be committed before calling — no file save/restore needed.
  */
 export async function gitSync(vaultPath) {
-    const git = simpleGit(vaultPath);
+    const git = vaultGit(vaultPath);
     if (!(await hasOriginRemote(git))) {
         return { pulled: false, pushed: false, remote: false };
     }
@@ -330,7 +373,7 @@ export async function gitSync(vaultPath) {
  */
 async function gitUnstage(vaultPath, files) {
     try {
-        await simpleGit(vaultPath).raw(['reset', '-q', 'HEAD', '--', ...files]);
+        await vaultGit(vaultPath).raw(['reset', '-q', 'HEAD', '--', ...files]);
     }
     catch { /* best effort — rollback must not mask the original error */ }
 }
@@ -390,20 +433,40 @@ function parseNameStatusLine(line) {
     const operation = FILE_STATUS_MAP[match[1]];
     return operation ? [{ path: match[2], operation }] : [];
 }
-export async function gitChangelog(vaultPath, since) {
-    const git = simpleGit(vaultPath);
+/**
+ * Read-side "no history": the one state where `git log` has nothing to say
+ * and empty is the true answer — a repo with no commits yet. Everything else
+ * (a directory that is not a repository, an env-guard or unsafe-category
+ * rejection, a missing git binary, a corrupt repo) is a failure the write
+ * side already reports loudly, so the read side must not hide it. Matched on
+ * git's stderr text, which simple-git carries in `GitError.message`; both
+ * callers pass a `--` pathspec and no revision, and an unborn HEAD then says
+ * exactly this.
+ */
+const NO_HISTORY_RE = /does not have any commits yet/i;
+function isNoHistory(err) {
+    return NO_HISTORY_RE.test(err instanceof Error ? err.message : String(err));
+}
+function gitReadFailed(err) {
+    const lines = (err instanceof Error ? err.message : String(err)).split('\n').map(l => l.trim()).filter(Boolean);
+    return new HafezError('GIT_READ_FAILED', `git read failed: ${lines[0] ?? 'unknown error'}`, lines);
+}
+export async function gitChangelog(vaultPath, since, limit) {
+    const git = vaultGit(vaultPath);
     // Bare dates become local midnight — the same calendar-day boundary the
     // vault stamps and query comparisons use (see dates.ts).
     const normalizedSince = normalizeSinceDate(since);
     let output;
     try {
         output = await git.raw([
-            'log', `--since=${normalizedSince}`, '--name-status',
+            'log', ...(since ? [`--since=${normalizedSince}`] : []), ...(limit === undefined ? [] : [`--max-count=${limit}`]), '--name-status',
             '--pretty=format:%H|%aI|%s', '--', ...INDEXED_DIR_PATHSPECS,
         ]);
     }
-    catch {
-        return []; // No git history or invalid since — return empty
+    catch (err) {
+        if (isNoHistory(err))
+            return [];
+        throw gitReadFailed(err);
     }
     if (!output.trim())
         return [];
@@ -416,7 +479,7 @@ export async function gitChangelog(vaultPath, since) {
         const headerMatch = lines[0].match(/^([0-9a-f]+)\|(.+?)\|(.*)$/);
         if (!headerMatch)
             continue;
-        const [, , timestamp, commit_message] = headerMatch;
+        const [, commit, timestamp, commit_message] = headerMatch;
         for (let i = 1; i < lines.length; i++) {
             for (const { path: filePath, operation } of parseNameStatusLine(lines[i])) {
                 // Only vault documents — scaffold files (.gitkeep) live in the same
@@ -426,7 +489,7 @@ export async function gitChangelog(vaultPath, since) {
                 const classified = classifyIndexedRelPath(filePath);
                 if (!classified)
                     continue;
-                entries.push({ slug: classified.slug, kind: classified.kind, operation, timestamp, commit_message });
+                entries.push({ slug: classified.slug, kind: classified.kind, operation, timestamp, commit_message, commit });
             }
         }
     }
@@ -439,7 +502,7 @@ export async function gitChangelog(vaultPath, since) {
  * Files with no history (not yet committed) are absent from the map.
  */
 export async function gitFileTimes(vaultPath, mode) {
-    const git = simpleGit(vaultPath);
+    const git = vaultGit(vaultPath);
     let output;
     try {
         const args = ['log', '--pretty=format:%x00%aI', '--name-only', '--', ...INDEXED_DIR_PATHSPECS];
@@ -447,8 +510,10 @@ export async function gitFileTimes(vaultPath, mode) {
             args.splice(1, 0, '--diff-filter=A');
         output = await git.raw(args);
     }
-    catch {
-        return new Map(); // no git history
+    catch (err) {
+        if (isNoHistory(err))
+            return new Map();
+        throw gitReadFailed(err);
     }
     const times = new Map();
     let current = '';
@@ -463,8 +528,49 @@ export async function gitFileTimes(vaultPath, mode) {
     }
     return times;
 }
+const CHANGE_OPS = { created: 'create', updated: 'update', deleted: 'delete' };
+/**
+ * The Journal's changesSince: HEAD as the cursor, and the indexed-dir files
+ * whose content differs between `from` and HEAD. A diff between two points,
+ * not a walk of the commits in between, so the status is the net one: a file
+ * made and removed inside the span is not there. core.quotePath off keeps
+ * non-ASCII paths (legitimate slugs) unquoted.
+ */
+export async function gitChangesSince(vaultPath, from) {
+    const git = vaultGit(vaultPath);
+    let cursor;
+    try {
+        cursor = (await git.raw(['log', '-1', '--format=%H'])).trim();
+    }
+    catch (err) {
+        if (isNoHistory(err))
+            return { cursor: '', files: [] };
+        throw gitReadFailed(err);
+    }
+    if (from === undefined || from === cursor)
+        return { cursor, files: [] };
+    const files = [];
+    try {
+        if (from === '') {
+            const listed = await git.raw(['-c', 'core.quotePath=false', 'ls-tree', '-r', '--name-only', cursor, '--', ...INDEXED_DIR_PATHSPECS]);
+            for (const path of listed.split('\n').filter(Boolean))
+                files.push({ path, op: 'create' });
+        }
+        else {
+            const diff = await git.raw(['-c', 'core.quotePath=false', 'diff', '--name-status', from, cursor, '--', ...INDEXED_DIR_PATHSPECS]);
+            for (const line of diff.split('\n')) {
+                for (const { path, operation } of parseNameStatusLine(line))
+                    files.push({ path, op: CHANGE_OPS[operation] });
+            }
+        }
+    }
+    catch (err) {
+        throw gitReadFailed(err);
+    }
+    return { cursor, files };
+}
 export async function gitCommitAndPush(vaultPath, files, message, config = {}) {
-    const git = simpleGit(vaultPath);
+    const git = vaultGit(vaultPath);
     // If a previous run crashed mid-rebase/merge, the repo is stuck.
     // Aborting restores tracked files to their pre-rebase state, which may
     // overwrite files that index.ts just wrote. Save and restore them.
@@ -536,7 +642,8 @@ export function createGitJournal(vaultPath, config = {}) {
             }
         },
         sync: () => gitSync(vaultPath),
-        changelog: (since) => gitChangelog(vaultPath, since),
+        changelog: (since, limit) => gitChangelog(vaultPath, since, limit),
         fileTimes: (mode) => gitFileTimes(vaultPath, mode),
+        changesSince: (from) => gitChangesSince(vaultPath, from),
     };
 }

package/dist/graph/activity.d.ts

@@ -0,0 +1,5 @@
+import type { ActivityRow, Hafez } from '../types.js';
+/** How many rows `/activity` lists. */
+export declare const ACTIVITY_ROWS = 20;
+/** `names` maps a slug to the name its node carries now. */
+export declare function activity(os: Hafez, names: Map<string, string>): Promise<ActivityRow[]>;

package/dist/graph/activity.js

@@ -0,0 +1,70 @@
+import { parseSessionLog } from '../document.js';
+import { localDay } from '../dates.js';
+import { kindDir, noteAtRelPath } from '../vault.js';
+/** How many rows `/activity` lists. */
+export const ACTIVITY_ROWS = 20;
+/** How many of the newest commits are read first: a history read costs
+ * ~25 ms a commit on drvfs, so the whole history is never read at once.
+ * While those collapse into fewer rows, twice as many are read, until the
+ * rows are full or a read covers fewer commits than it asked for (the
+ * history's end). */
+const COMMITS_READ = 50;
+const OP = { created: 'create', updated: 'update', deleted: 'delete' };
+/** `names` maps a slug to the name its node carries now. */
+export async function activity(os, names) {
+    for (let commits = COMMITS_READ;; commits *= 2) {
+        const entries = await os.changelog('', commits);
+        const { rows, full } = collapse(entries, names);
+        // The commits the read covered, counted by hash: every note commit lists
+        // at least one entry (a commit touching no note under a note dir, the
+        // scaffold's .gitkeep, is the history's first).
+        if (full || new Set(entries.map(e => e.commit)).size < commits)
+            return withAgents(os, rows);
+    }
+}
+/** The changelog's entries as rows, newest first; `full` once a row past the
+ * last has begun, so the last row's run of writes is known to be whole. */
+function collapse(entries, names) {
+    const rows = [];
+    for (const e of entries) {
+        // The changelog lists every file under a kind dir, an archive log
+        // (`entities/archive/<slug>-log.md`) too; the Layout says which are notes.
+        if (!noteAtRelPath(`${kindDir(e.kind)}/${e.slug}.md`))
+            continue;
+        const op = OP[e.operation];
+        const last = rows[rows.length - 1];
+        if (last?.slug === e.slug) {
+            // A promote deletes and creates the note in one commit: one write, and
+            // the create is what happened to it.
+            if (last.commit === e.commit && (last.op === 'delete') !== (op === 'delete')) {
+                if (op !== 'delete' && last.count === 1)
+                    Object.assign(last, { op, kind: e.kind });
+            }
+            else {
+                last.count++;
+                last.commit = e.commit;
+            }
+            continue;
+        }
+        if (rows.length === ACTIVITY_ROWS)
+            return { rows, full: true };
+        rows.push({ slug: e.slug, kind: e.kind, op, timestamp: e.timestamp, name: names.get(e.slug) ?? e.slug, count: 1, commit: e.commit });
+    }
+    return { rows, full: false };
+}
+/** Each Entity row with the agent its Session Log records for the write's day. */
+function withAgents(os, rows) {
+    return Promise.all(rows.map(async ({ commit: _, ...row }) => {
+        const agent = row.kind === 'entity' && row.op !== 'delete' ? await agentOf(os, row.slug, localDay(new Date(row.timestamp))) : undefined;
+        return agent ? { ...row, agent } : row;
+    }));
+}
+/** The agent of the Entity's newest Session Log entry dated `day`. */
+async function agentOf(os, slug, day) {
+    try {
+        return parseSessionLog((await os.read(slug, 'full')).body).find(entry => entry.date === day)?.agent;
+    }
+    catch {
+        return undefined; // gone since: nothing to read the agent from
+    }
+}