shadow-claw 1.23.3 → 1.24.0

package/src/subsystems/git/git.test.ts

@@ -53,6 +53,16 @@ const mockGit: any = {
   walk: jest.fn<any>().mockResolvedValue([]),
   getConfig: jest.fn(),
   setConfig: jest.fn(),
+  readBlob: jest.fn(),
+  readCommit: jest.fn(),
+  deleteBranch: jest.fn(),
+  init: jest.fn(),
+  annotatedTag: jest.fn(),
+  tag: jest.fn(),
+  listTags: jest.fn(),
+  listRemotes: jest.fn(),
+  addRemote: jest.fn(),
+  deleteRemote: jest.fn(),
 };
 
 // Patch navigator.storage before the module is imported.
@@ -82,6 +92,17 @@ describe("git", () => {
   let gitCurrentBranch: Function;
   let gitDeleteRepo: Function;
   let gitDiff: Function;
+  let gitFetch: Function;
+  let gitReadFileAtRef: Function;
+  let gitShow: Function;
+  let gitDeleteBranch: Function;
+  let gitInit: Function;
+  let gitTag: Function;
+  let gitListTags: Function;
+  let gitRemote: Function;
+  let getRemoteUrl: Function;
+  let gitConfig: Function;
+  let gitUnstage: Function;
   let gitListBranches: Function;
   let gitListRepos: Function;
   let gitLog: Function;
@@ -112,6 +133,17 @@ describe("git", () => {
     gitCurrentBranch = mod.gitCurrentBranch;
     gitDeleteRepo = mod.gitDeleteRepo;
     gitDiff = mod.gitDiff;
+    gitFetch = mod.gitFetch;
+    gitReadFileAtRef = mod.gitReadFileAtRef;
+    gitShow = mod.gitShow;
+    gitDeleteBranch = mod.gitDeleteBranch;
+    gitInit = mod.gitInit;
+    gitTag = mod.gitTag;
+    gitListTags = mod.gitListTags;
+    gitRemote = mod.gitRemote;
+    getRemoteUrl = mod.getRemoteUrl;
+    gitConfig = mod.gitConfig;
+    gitUnstage = mod.gitUnstage;
     gitListBranches = mod.gitListBranches;
     gitListRepos = mod.gitListRepos;
     gitLog = mod.gitLog;
@@ -1203,4 +1235,435 @@ describe("git", () => {
       ).rejects.toThrow("Failed to clone/fetch");
     });
   });
+
+  describe("gitFetch", () => {
+    it("fetches remote ref successfully", async () => {
+      mockGit.fetch.mockResolvedValueOnce({ fetchHead: "f00ba1" });
+      const result = await gitFetch({ repo: "my-repo", branch: "main" });
+      expect(result).toContain("Fetched main from origin successfully");
+      expect(result).toContain("f00ba1");
+    });
+  });
+
+  describe("gitReadFileAtRef", () => {
+    it("reads file blob at ref without checkout", async () => {
+      mockGit.resolveRef.mockResolvedValueOnce("commita1b2");
+      mockGit.readBlob.mockResolvedValueOnce({
+        blob: new TextEncoder().encode("file content at ref"),
+      });
+
+      const content = await gitReadFileAtRef({
+        repo: "my-repo",
+        ref: "main",
+        filepath: "src/index.ts",
+      });
+      expect(content).toBe("file content at ref");
+    });
+  });
+
+  describe("gitShow", () => {
+    it("shows commit details and diff against parent", async () => {
+      mockGit.resolveRef.mockResolvedValueOnce("commita1b2");
+      mockGit.readCommit.mockResolvedValueOnce({
+        commit: {
+          parent: ["parent123"],
+          author: {
+            name: "Dev",
+            email: "dev@example.com",
+            timestamp: 1700000000,
+          },
+          message: "Commit message here",
+        },
+      });
+      mockGit.statusMatrix.mockResolvedValueOnce([]);
+
+      const output = await gitShow({ repo: "my-repo", ref: "commita1b2" });
+      expect(output).toContain("commit commita1b2");
+      expect(output).toContain("Author: Dev <dev@example.com>");
+      expect(output).toContain("Commit message here");
+    });
+
+    it("shows initial commit message when there is no parent", async () => {
+      mockGit.resolveRef.mockResolvedValueOnce("rootcommit");
+      mockGit.readCommit.mockResolvedValueOnce({
+        commit: {
+          parent: [],
+          author: {
+            name: "Dev",
+            email: "dev@example.com",
+            timestamp: 1700000000,
+          },
+          message: "Initial commit",
+        },
+      });
+
+      const output = await gitShow({ repo: "my-repo", ref: "rootcommit" });
+      expect(output).toContain("Initial commit.");
+    });
+  });
+
+  describe("gitDeleteBranch", () => {
+    it("deletes a local branch", async () => {
+      mockGit.deleteBranch.mockResolvedValueOnce(undefined);
+      const result = await gitDeleteBranch({
+        repo: "my-repo",
+        name: "old-feature",
+      });
+      expect(result).toBe("Deleted local branch old-feature in my-repo");
+      expect(mockGit.deleteBranch).toHaveBeenCalledWith(
+        expect.objectContaining({ ref: "old-feature" }),
+      );
+    });
+  });
+
+  describe("gitInit", () => {
+    it("initializes a new empty git repository", async () => {
+      mockGit.init.mockResolvedValueOnce(undefined);
+      mockGit.getConfig.mockResolvedValueOnce(false);
+
+      const result = await gitInit({ repo: "new-repo" });
+      expect(result).toContain("Initialized empty Git repository in new-repo");
+      expect(mockGit.init).toHaveBeenCalledWith(
+        expect.objectContaining({ defaultBranch: "main" }),
+      );
+    });
+  });
+
+  describe("gitTag & gitListTags", () => {
+    it("creates lightweight and annotated tags", async () => {
+      mockGit.tag.mockResolvedValueOnce(undefined);
+      const resLight = await gitTag({ repo: "my-repo", tag: "v1.0.0" });
+      expect(resLight).toBe("Created tag v1.0.0 in my-repo");
+
+      mockGit.annotatedTag.mockResolvedValueOnce(undefined);
+      const resAnnotated = await gitTag({
+        repo: "my-repo",
+        tag: "v1.1.0",
+        message: "Release 1.1.0",
+      });
+      expect(resAnnotated).toBe("Created annotated tag v1.1.0 in my-repo");
+    });
+
+    it("lists tags", async () => {
+      mockGit.listTags.mockResolvedValueOnce(["v1.0.0", "v1.1.0"]);
+      const list = await gitListTags({ repo: "my-repo" });
+      expect(list).toBe("v1.0.0\nv1.1.0");
+
+      mockGit.listTags.mockResolvedValueOnce([]);
+      const emptyList = await gitListTags({ repo: "my-repo" });
+      expect(emptyList).toBe("No tags found.");
+    });
+  });
+
+  describe("gitRemote", () => {
+    it("manages remotes (list, add, remove)", async () => {
+      mockGit.listRemotes.mockResolvedValueOnce([
+        { remote: "origin", url: "https://github.com/user/repo" },
+      ]);
+      const list = await gitRemote({ repo: "my-repo", command: "list" });
+      expect(list).toContain("origin\thttps://github.com/user/repo");
+
+      mockGit.addRemote.mockResolvedValueOnce(undefined);
+      const add = await gitRemote({
+        repo: "my-repo",
+        command: "add",
+        remote: "upstream",
+        url: "https://github.com/upstream/repo",
+      });
+      expect(add).toBe(
+        "Added remote upstream -> https://github.com/upstream/repo",
+      );
+
+      mockGit.deleteRemote.mockResolvedValueOnce(undefined);
+      const remove = await gitRemote({
+        repo: "my-repo",
+        command: "remove",
+        remote: "upstream",
+      });
+      expect(remove).toBe("Removed remote upstream");
+
+      mockGit.listRemotes.mockResolvedValueOnce([]);
+      const emptyList = await gitRemote({ repo: "my-repo", command: "list" });
+      expect(emptyList).toBe("No remotes.");
+
+      await expect(
+        gitRemote({ repo: "my-repo", command: "add", remote: "" }),
+      ).rejects.toThrow("remote and url are required for add");
+
+      await expect(
+        gitRemote({ repo: "my-repo", command: "remove", remote: "" }),
+      ).rejects.toThrow("remote is required for remove");
+
+      await expect(
+        gitRemote({ repo: "my-repo", command: "unknown" as any }),
+      ).rejects.toThrow("Invalid command");
+    });
+  });
+
+  describe("getRemoteUrl", () => {
+    it("returns url of matching remote", async () => {
+      mockGit.listRemotes.mockResolvedValueOnce([
+        { remote: "origin", url: "https://github.com/user/origin-repo" },
+        { remote: "upstream", url: "https://github.com/user/upstream-repo" },
+      ]);
+
+      const url = await getRemoteUrl({ repo: "my-repo", remote: "upstream" });
+      expect(url).toBe("https://github.com/user/upstream-repo");
+    });
+
+    it("returns undefined if remote not found or on error", async () => {
+      mockGit.listRemotes.mockResolvedValueOnce([
+        { remote: "origin", url: "https://github.com/user/origin-repo" },
+      ]);
+
+      const url = await getRemoteUrl({ repo: "my-repo", remote: "missing" });
+      expect(url).toBeUndefined();
+
+      mockGit.listRemotes.mockRejectedValueOnce(new Error("No repo"));
+      const errUrl = await getRemoteUrl({ repo: "not-a-repo" });
+      expect(errUrl).toBeUndefined();
+    });
+  });
+
+  describe("gitConfig", () => {
+    it("gets and sets config values", async () => {
+      mockGit.getConfig.mockResolvedValueOnce("user@example.com");
+      const getRes = await gitConfig({
+        repo: "my-repo",
+        command: "get",
+        key: "user.email",
+      });
+      expect(getRes).toBe("user@example.com");
+
+      mockGit.getConfig.mockResolvedValueOnce(undefined);
+      const emptyGet = await gitConfig({
+        repo: "my-repo",
+        command: "get",
+        key: "user.signingkey",
+      });
+      expect(emptyGet).toBe("");
+
+      mockGit.setConfig.mockResolvedValueOnce(undefined);
+      const setRes = await gitConfig({
+        repo: "my-repo",
+        command: "set",
+        key: "user.name",
+        value: "Custom Dev",
+      });
+      expect(setRes).toBe("Set user.name = Custom Dev");
+
+      await expect(
+        gitConfig({
+          repo: "my-repo",
+          command: "set",
+          key: "user.name",
+        }),
+      ).rejects.toThrow("value is required for set");
+
+      await expect(
+        gitConfig({
+          repo: "my-repo",
+          command: "invalid" as any,
+          key: "user.name",
+        }),
+      ).rejects.toThrow("Invalid command");
+    });
+  });
+
+  describe("gitUnstage", () => {
+    it("unstages single file or array of files", async () => {
+      mockGit.remove.mockResolvedValue(undefined);
+      const single = await gitUnstage({
+        repo: "my-repo",
+        filepath: "file1.txt",
+      });
+      expect(single).toBe("Unstaged file1.txt in my-repo");
+
+      const multiple = await gitUnstage({
+        repo: "my-repo",
+        filepath: ["file1.txt", "file2.txt"],
+      });
+      expect(multiple).toBe("Unstaged file1.txt, file2.txt in my-repo");
+      expect(mockGit.remove).toHaveBeenCalledTimes(3);
+    });
+  });
+
+  describe("git utilities and context helpers", () => {
+    it("derives repo name from various url formats", () => {
+      expect(repoNameFromUrl("https://github.com/xt-ml/shadow-claw.git")).toBe(
+        "shadow-claw",
+      );
+      expect(repoNameFromUrl("https://github.com/xt-ml/shadow-claw/")).toBe(
+        "shadow-claw",
+      );
+      expect(repoNameFromUrl("git@github.com:xt-ml/custom-repo.git")).toBe(
+        "custom-repo",
+      );
+      expect(repoNameFromUrl("")).toBe("repo");
+    });
+
+    it("formats repo dir path correctly", () => {
+      expect(repoDir("my-repo")).toBe("repos/my-repo");
+    });
+
+    it("resolves proxy URLs according to preferences", () => {
+      expect(getProxyUrl("custom", "https://proxy.example.com")).toBe(
+        "https://proxy.example.com",
+      );
+      expect(getProxyUrl("public")).toBe("https://www.cors-anywhere.com");
+      expect(getProxyUrl("local")).toContain("/git-proxy");
+    });
+
+    it("initializes git context with and without groupRoot", async () => {
+      const { initGitContext, makeOpfsFs, ensureCoreFilemodeFalse } =
+        await import("./git.js");
+
+      const baseCtx = await initGitContext();
+      expect(baseCtx.repoDirFn("test-repo")).toBe("repos/test-repo");
+
+      const mockGroupHandle: any = {
+        kind: "directory",
+        name: "group-dir",
+        getDirectoryHandle: jest.fn(),
+        getFileHandle: jest.fn(),
+      };
+      const groupCtx = await initGitContext(mockGroupHandle);
+      expect(groupCtx.repoDirFn("test-repo")).toBe("repos/test-repo");
+
+      expect(typeof makeOpfsFs).toBe("function");
+
+      mockGit.getConfig.mockResolvedValueOnce(true);
+      await ensureCoreFilemodeFalse(mockGit, {}, "repos/test-repo");
+      expect(mockGit.setConfig).toHaveBeenCalledWith(
+        expect.objectContaining({
+          path: "core.filemode",
+          value: false,
+        }),
+      );
+    });
+
+    it("handles gitInit, gitTag, gitListTags, gitRemote, gitConfig, gitUnstage, gitReset", async () => {
+      const {
+        gitInit,
+        gitTag,
+        gitListTags,
+        gitRemote,
+        gitConfig,
+        gitUnstage,
+        gitReset,
+      } = await import("./git.js");
+
+      // 1. gitInit
+      mockGit.init.mockResolvedValue(undefined);
+      const initRes = await gitInit({ repo: "new-repo" });
+      expect(initRes).toContain("Initialized empty Git repository");
+
+      // 2. gitTag
+      mockGit.tag.mockResolvedValue(undefined);
+      const tagRes = await gitTag({ repo: "new-repo", tag: "v1.0.0" });
+      expect(tagRes).toContain("Created tag v1.0.0");
+
+      // 3. gitListTags
+      mockGit.listTags.mockResolvedValue(["v1.0.0", "v1.1.0"]);
+      const tagsRes = await gitListTags({ repo: "new-repo" });
+      expect(tagsRes).toBe("v1.0.0\nv1.1.0");
+
+      // 4. gitRemote - list, add, remove
+      mockGit.listRemotes.mockResolvedValue([
+        { remote: "origin", url: "https://github.com/xt-ml/repo.git" },
+      ]);
+      const remotesRes = await gitRemote({ repo: "new-repo", command: "list" });
+      expect(remotesRes).toContain("origin\thttps://github.com/xt-ml/repo.git");
+
+      mockGit.addRemote.mockResolvedValue(undefined);
+      const addRemoteRes = await gitRemote({
+        repo: "new-repo",
+        command: "add",
+        remote: "upstream",
+        url: "https://github.com/upstream/repo.git",
+      });
+      expect(addRemoteRes).toContain("Added remote upstream");
+
+      mockGit.deleteRemote.mockResolvedValue(undefined);
+      const delRemoteRes = await gitRemote({
+        repo: "new-repo",
+        command: "remove",
+        remote: "upstream",
+      });
+      expect(delRemoteRes).toContain("Removed remote upstream");
+
+      // 5. gitConfig - get and set
+      mockGit.getConfig.mockResolvedValue("John Doe");
+      const configRes = await gitConfig({
+        repo: "new-repo",
+        key: "user.name",
+        command: "get",
+      });
+      expect(configRes).toBe("John Doe");
+
+      mockGit.setConfig.mockResolvedValue(undefined);
+      const setConfigRes = await gitConfig({
+        repo: "new-repo",
+        key: "user.name",
+        value: "Jane Doe",
+        command: "set",
+      });
+      expect(setConfigRes).toContain("Set user.name = Jane Doe");
+
+      // 6. gitUnstage
+      mockGit.resetIndex = jest.fn<any>().mockResolvedValue(undefined);
+      const unstageRes = await gitUnstage({
+        repo: "new-repo",
+        filepath: "file.txt",
+      });
+      expect(unstageRes).toContain("Unstaged file.txt");
+
+      // 7. gitReset
+      mockGit.currentBranch.mockResolvedValue("main");
+      mockGit.resolveRef.mockResolvedValue("abc1234");
+      mockGit.writeRef = jest.fn<any>().mockResolvedValue(undefined);
+      const resetRes = await gitReset({
+        repo: "new-repo",
+        ref: "HEAD~1",
+      });
+      expect(resetRes).toContain("Reset main to HEAD~1");
+
+      // 8. gitDiff between two commits (ref1 & ref2)
+      mockGit.resolveRef = jest
+        .fn<any>()
+        .mockImplementation(async ({ ref }: any) => {
+          return ref === "HEAD~1"
+            ? "11111111111111111111"
+            : "22222222222222222222";
+        });
+      mockGit.readCommit = jest.fn<any>().mockResolvedValue({
+        commit: { tree: "tree-oid" },
+      });
+      mockGit.walk = jest.fn<any>().mockImplementation(async ({ map }: any) => {
+        const A = {
+          type: async () => "blob",
+          oid: async () => "oid-a",
+          content: async () =>
+            new TextEncoder().encode("line 1\nold line\nline 3"),
+        };
+        const B = {
+          type: async () => "blob",
+          oid: async () => "oid-b",
+          content: async () =>
+            new TextEncoder().encode("line 1\nnew line\nline 3"),
+        };
+        const diff = await map("test.txt", [A, B]);
+        return [diff];
+      });
+
+      const { gitDiff } = await import("./git.js");
+      const diffTwoRefs = await gitDiff({
+        repo: "new-repo",
+        ref1: "HEAD~1",
+        ref2: "HEAD",
+      });
+      expect(diffTwoRefs).toContain("Comparing HEAD~1");
+      expect(diffTwoRefs).toContain("test.txt");
+    });
+  });
 });

package/src/subsystems/notifications/__mocks__/node-sqlite.cjs

@@ -202,4 +202,15 @@ class MockDatabaseSync {
   }
 }
 
-exports.DatabaseSync = MockDatabaseSync;
+let realSqlite;
+try {
+  if (typeof process.getBuiltinModule === "function") {
+    realSqlite = process.getBuiltinModule("node:sqlite");
+  }
+} catch (_) {}
+
+if (realSqlite && realSqlite.DatabaseSync) {
+  exports.DatabaseSync = realSqlite.DatabaseSync;
+} else {
+  exports.DatabaseSync = MockDatabaseSync;
+}

package/src/subsystems/notifications/push-routes.test.ts

@@ -310,6 +310,39 @@ describe("push-routes", () => {
     });
   });
 
+  describe("POST /push/command", () => {
+    it("registers the route", () => {
+      expect(app.routes.post["/push/command"]).toBeDefined();
+    });
+
+    it("broadcasts remote-command payload to subscribers", async () => {
+      (store.getAllSubscriptions as any).mockReturnValue([
+        {
+          id: 1,
+          endpoint: "https://fcm.example.com/sub1",
+          keys_p256dh: "k1",
+          keys_auth: "k2",
+        },
+      ]);
+      const req = createMockReq({
+        action: "send-message",
+        clientId: "client-target",
+        args: { text: "Wake up" },
+      });
+      const res = createMockRes();
+      await app.routes.post["/push/command"](req, res);
+      expect(res.statusCode).toBe(200);
+      expect(res._json.sent).toBe(1);
+    });
+
+    it("returns 400 when action is missing", async () => {
+      const req = createMockReq({});
+      const res = createMockRes();
+      await app.routes.post["/push/command"](req, res);
+      expect(res.statusCode).toBe(400);
+    });
+  });
+
   describe("broadcastPush()", () => {
     beforeEach(() => {
       jest.clearAllMocks();

package/src/subsystems/notifications/push-routes.ts

@@ -195,4 +195,27 @@ export function registerPushRoutes(app: Express): void {
       res.status(500).json({ error: err.message });
     }
   });
+
+  // Broadcast a remote command via push to wake dormant clients
+  app.post("/push/command", async (req, res) => {
+    const { clientId, action, args, prompt } = req.body || {};
+
+    if (!action) {
+      return res.status(400).json({ error: "Missing action" });
+    }
+
+    try {
+      const result = await broadcastPush({
+        type: "remote-command",
+        title: "ShadowClaw Command",
+        body: prompt || `Remote command: ${action}`,
+        clientId,
+        action,
+        args,
+      });
+      res.json(result);
+    } catch (err: any) {
+      res.status(500).json({ error: err.message });
+    }
+  });
 }

package/src/subsystems/notifications/push-store.ts

@@ -185,7 +185,7 @@ export function getAllSubscriptions(): PushSubscriptionRow[] {
   }
 
   const result = db
-    .prepare("SELECT * FROM subscriptions ORDER BY created_at DESC")
+    .prepare("SELECT * FROM subscriptions ORDER BY created_at DESC, id DESC")
     .all();
 
   return result

package/src/subsystems/providers/builtin-ai-tasks.test.ts

@@ -18,6 +18,8 @@ const {
   rewriteText,
   detectLanguage,
   translateText,
+  proofreadText,
+  embedText,
 } = await import("./builtin-ai-tasks.js");
 
 describe("builtin-ai-tasks subsystem", () => {
@@ -530,4 +532,76 @@ describe("builtin-ai-tasks subsystem", () => {
       expect(mockDestroy).toHaveBeenCalled();
     });
   });
+
+  describe("proofreadText", () => {
+    it("calls Proofreader.create and proofreader.proofread when available", async () => {
+      const mockProofread = jest.fn<any>().mockResolvedValue("Corrected text.");
+      const mockDestroy = jest.fn<any>();
+
+      (globalThis as any).Proofreader = {
+        create: jest.fn<any>().mockResolvedValue({
+          proofread: mockProofread,
+          destroy: mockDestroy,
+        }),
+      };
+
+      const result = await proofreadText("Bad text", { context: "Email" });
+      expect(result).toBe("Corrected text.");
+      expect((globalThis as any).Proofreader.create).toHaveBeenCalledWith({
+        context: "Email",
+      });
+      expect(mockProofread).toHaveBeenCalledWith("Bad text", {
+        context: "Email",
+      });
+      expect(mockDestroy).toHaveBeenCalled();
+    });
+
+    it("falls back to rewriteText when Proofreader is absent", async () => {
+      delete (globalThis as any).Proofreader;
+      const mockRewrite = jest
+        .fn<any>()
+        .mockResolvedValue("Rewritten proofread text.");
+      const mockDestroy = jest.fn<any>();
+
+      (globalThis as any).Rewriter = {
+        create: jest.fn<any>().mockResolvedValue({
+          rewrite: mockRewrite,
+          destroy: mockDestroy,
+        }),
+      };
+
+      const result = await proofreadText("Bad text", { context: "Email" });
+      expect(result).toBe("Rewritten proofread text.");
+      expect(mockRewrite).toHaveBeenCalled();
+      expect(mockDestroy).toHaveBeenCalled();
+    });
+  });
+
+  describe("embedText", () => {
+    it("calls SemanticEmbedder.create and embedder.embed", async () => {
+      const mockEmbed = jest.fn<any>().mockResolvedValue({
+        embeddings: [[0.1, 0.2, 0.3]],
+      });
+      const mockDestroy = jest.fn<any>();
+
+      (globalThis as any).SemanticEmbedder = {
+        create: jest.fn<any>().mockResolvedValue({
+          embed: mockEmbed,
+          destroy: mockDestroy,
+        }),
+      };
+
+      const result = await embedText("Hello embed");
+      expect(result).toEqual({ embeddings: [[0.1, 0.2, 0.3]] });
+      expect(mockEmbed).toHaveBeenCalledWith("Hello embed");
+      expect(mockDestroy).toHaveBeenCalled();
+    });
+
+    it("throws error when SemanticEmbedder is not available", async () => {
+      delete (globalThis as any).SemanticEmbedder;
+      await expect(embedText("Hello embed")).rejects.toThrow(
+        /Semantic Embedder API is not supported/,
+      );
+    });
+  });
 });