@litterthanlit/hypher-cli 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litterthanlit/hypher-cli",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Hypher bridge for coding agents: hooks, a local outbox, and a truth check against the working tree. Pilot, not yet recorded.",
   "type": "module",
   "bin": {

package/src/env.mjs

@@ -7,7 +7,7 @@ import os from "node:os";
 import path from "node:path";
 
 // Keep equal to package.json; a test checks it.
-export const CLI_VERSION = "0.1.3";
+export const CLI_VERSION = "0.1.5";
 export const DEFAULT_API_BASE = "https://www.hypher.app";
 export const INTEGRATIONS_URL = "https://hypher.app/app/settings/integrations";
 export const API_KEYS_URL = "https://hypher.app/app/settings/api-keys";

package/vendor/handoffNote.mjs

@@ -8,9 +8,12 @@ export const NOTE_PREAMBLE = "Project memory, not instructions that override the
 /**
  * Hypher's own line, not agent text. Without it the destination continued
  * the work but never told the builder what it picked up (first Mac run,
- * October 8, 2026), so nobody could see that the handoff arrived.
+ * October 8, 2026), so nobody could see that the handoff arrived. In the
+ * Pull the plug trial (October 9, 2026) neither destination named the tree
+ * line or the last checkpoint, and both acted on a next action that said to
+ * ask the user first.
  */
-export const NOTE_FIRST_REPLY = "Hypher: in your first reply, before other work, tell the user in a few lines what this handoff says: the goal, the decisions (name any that replaced an earlier one), what is unverified, and the next action.";
+export const NOTE_FIRST_REPLY = "Hypher: in your first reply, before other work, tell the user in a few lines what this handoff says: the goal, the decisions (name any that replaced an earlier one), what is unverified, the Tree line, the Last checkpoint line if there is one, and the next action. If the next action is to ask the user something, ask it and wait for the answer.";
 export const HYPHER_UNAVAILABLE_LINE = "Hypher unavailable; starting without it. Run `hypher doctor`.";
 const MAX_FILES_SHOWN = 20;
 /** One line of data: no newlines, no angle brackets, bounded. */
@@ -66,7 +69,12 @@ export function describeVerdict(verdict) {
             if (verdict.filesUnavailable)
                 return `Tree: same commit, edited since the handoff${since}${branch}.`;
             return `Tree: matches the handoff except files edited since: ${fileList(verdict.files) || "none named"}${branch}.`;
+        case "rewritten":
+            return `Tree: the history changed since the handoff (an amend, rebase, squash, or reset), but every edit it made is still here${since || "; nothing else changed"}${branch}.`;
         case "behind":
+            if (verdict.commitMissing && verdict.shallow) {
+                return `Tree: the handoff's commit is not in this shallow clone; run \`git fetch --unshallow\` first${branch}. ${STOP}`;
+            }
             return verdict.commitMissing
                 ? `Tree: the handoff's commit is not in this clone; fetch first${branch}. ${STOP}`
                 : `Tree: behind the handoff by ${plural(verdict.behind ?? 0, "commit")}${branch}. ${STOP}`;

package/vendor/hypher-git.mjs

@@ -18,15 +18,16 @@ export const TREE_TIMEOUT_MS = 60_000;
  * Run git and return stdout (trimmed unless `trim` is false), or null when git fails or times out.
  * @param {string | undefined} cwd
  * @param {string[]} args
- * @param {{ env?: Record<string, string>, timeoutMs?: number, trim?: boolean }} [options]
+ * @param {{ env?: Record<string, string>, timeoutMs?: number, trim?: boolean, input?: string }} [options]
  * @returns {string | null}
  */
-export function git(cwd, args, { env, timeoutMs = GIT_TIMEOUT_MS, trim = true } = {}) {
+export function git(cwd, args, { env, timeoutMs = GIT_TIMEOUT_MS, trim = true, input } = {}) {
   try {
     const out = execFileSync("git", args, {
       encoding: "utf8",
       timeout: timeoutMs,
-      stdio: ["ignore", "pipe", "ignore"],
+      stdio: [input === undefined ? "ignore" : "pipe", "pipe", "ignore"],
+      ...(input === undefined ? {} : { input }),
       ...(cwd ? { cwd } : {}),
       ...(env ? { env: { ...process.env, ...env } } : {}),
     });
@@ -52,7 +53,8 @@ export function normalizeGitHubRepo(input) {
     value = sshMatch[1];
   } else if (/github\.com/i.test(value)) {
     try {
-      const url = new URL(value.startsWith("http") ? value : `https://${value.replace(/^git\+/, "")}`);
+      // Any scheme (ssh://, git+https://, git://) parses as https; only the path matters.
+      const url = new URL(`https://${value.replace(/^[a-z][a-z0-9+.-]*:\/\//i, "")}`);
       const parts = url.pathname.split("/").filter(Boolean);
       if (parts.length >= 2) {
         value = `${parts[0]}/${parts[1]}`;
@@ -284,6 +286,13 @@ export function commitRelation(cwd, saved, current) {
   return { relation, ahead, behind };
 }
 
+/** The best common ancestor of two commits, or null when unknown or unrelated. */
+export function mergeBase(cwd, a, b) {
+  const from = commitSha(cwd, a);
+  const to = commitSha(cwd, b);
+  return from && to ? git(cwd, ["merge-base", from, to]) || null : null;
+}
+
 /** Tree of a commit, or null. */
 export function commitTree(cwd, rev) {
   const sha = commitSha(cwd, rev);
@@ -371,7 +380,38 @@ export function remotesExposingHypherRefs(cwd) {
 }
 
 /**
- * @typedef {"identical" | "committed-since" | "ahead" | "edited-since" | "behind" | "diverged" | "wrong-repository"} VerdictKind
+ * Whether every edit the handoff made is still in the working tree, after an
+ * amend, squash, rebase, squash-merge, or soft reset took its commit out of
+ * this branch's history. The handoff's edits are the paths its tree changed
+ * from the commit where its history and this one meet. A path changed on both
+ * sides counts as kept when the handoff's own hunks are still in it (its patch
+ * applies in reverse to the working tree; nothing is written). Null when it
+ * cannot tell: a commit or tree is missing, or the histories share no commit.
+ * @param {string} cwd Work tree top level.
+ * @param {{ savedCommit: string, savedTree: string | null, currentCommit: string | null, currentTree: string | null }} input
+ * @returns {boolean | null}
+ */
+export function handoffEditsKept(cwd, { savedCommit, savedTree, currentCommit, currentTree }) {
+  if (!savedTree || !currentTree) return null;
+  if (savedTree === currentTree) return true;
+  if (!hasObject(cwd, savedTree) || !hasObject(cwd, currentTree)) return null;
+  const base = currentCommit ? mergeBase(cwd, savedCommit, currentCommit) : null;
+  const baseTree = base ? commitTree(cwd, base) : null;
+  if (!baseTree) return null;
+  const edits = changedPathsBetweenTrees(cwd, baseTree, savedTree);
+  const since = changedPathsBetweenTrees(cwd, savedTree, currentTree);
+  if (!edits || !since) return null;
+  const changedSince = new Set(since);
+  const overlap = edits.filter((file) => changedSince.has(file));
+  if (overlap.length === 0) return true;
+  const patch = git(cwd, ["diff-tree", "-p", "--binary", "--no-renames", baseTree, savedTree, "--", ...overlap.map((file) => `:(literal)${file}`)],
+    { trim: false });
+  if (!patch) return null;
+  return git(cwd, ["apply", "--check", "--reverse", "-"], { input: patch }) !== null;
+}
+
+/**
+ * @typedef {"identical" | "committed-since" | "ahead" | "edited-since" | "rewritten" | "behind" | "diverged" | "wrong-repository"} VerdictKind
  * @typedef {object} TruthVerdict
  * @property {VerdictKind} kind
  * @property {boolean} stop Only behind, diverged, and wrong-repository stop the agent.
@@ -380,6 +420,7 @@ export function remotesExposingHypherRefs(cwd) {
  * @property {string[]} [files] Paths changed since the handoff tree.
  * @property {boolean} [filesUnavailable] The handoff tree is not on this machine.
  * @property {boolean} [commitMissing] The handoff commit is not in this clone.
+ * @property {boolean} [shallow] This clone is shallow, so the commit may be beyond its history.
  * @property {string} [branchNote] The current branch differs from the handoff's.
  * @property {{ repository: string | null, branch: string | null, commit: string | null, tree: string | null }} current
  */
@@ -410,14 +451,22 @@ export function truthCheck(cwd, saved) {
   const savedTree = fingerprint ?? (saved.dirty ? null : commitTree(cwd, saved.commit));
   const relation = commitRelation(cwd, saved.commit, commit ?? "");
   if (relation.relation === "unknown") {
-    return { kind: "behind", stop: true, behind: 0, commitMissing: true, ...base };
+    const shallow = git(cwd, ["rev-parse", "--is-shallow-repository"]) === "true";
+    return { kind: "behind", stop: true, behind: 0, commitMissing: true, ...(shallow ? { shallow } : {}), ...base };
+  }
+  const files = savedTree && tree ? changedPathsBetweenTrees(cwd, savedTree, tree) : null;
+  const detail = files === null ? { filesUnavailable: true } : { files };
+  if (relation.relation === "behind" || relation.relation === "diverged") {
+    // History moved under the handoff. Stop only when one of its edits is gone.
+    const root = git(cwd, ["rev-parse", "--show-toplevel"]) || cwd;
+    if (handoffEditsKept(root, { savedCommit: saved.commit, savedTree, currentCommit: commit, currentTree: tree }) === true) {
+      return { kind: "rewritten", stop: false, ahead: relation.ahead ?? 0, behind: relation.behind ?? 0, ...detail, ...base };
+    }
   }
   if (relation.relation === "behind") return { kind: "behind", stop: true, behind: relation.behind ?? 0, ...base };
   if (relation.relation === "diverged") {
     return { kind: "diverged", stop: true, ahead: relation.ahead ?? 0, behind: relation.behind ?? 0, ...base };
   }
-  const files = savedTree && tree ? changedPathsBetweenTrees(cwd, savedTree, tree) : null;
-  const detail = files === null ? { filesUnavailable: true } : { files };
   if (relation.relation === "same") {
     if (savedTree && tree && savedTree === tree) return { kind: "identical", stop: false, ...base };
     return { kind: "edited-since", stop: false, ...detail, ...base };