@meshxdata/fops 0.0.1 → 0.0.4

package/src/agent/agent.test.js

@@ -1,233 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { formatResponse, extractSuggestedCommands } from "./agent.js";
-
-describe("agent", () => {
-  describe("formatResponse", () => {
-    it("prefixes first line with bullet", () => {
-      const result = formatResponse("hello");
-      expect(result).toContain("hello");
-      expect(result).toMatch(/⏺/);
-    });
-
-    it("renders headings", () => {
-      const result = formatResponse("# My Heading\nsome text");
-      expect(result).toContain("My Heading");
-    });
-
-    it("renders h2 headings", () => {
-      const result = formatResponse("## Sub Heading");
-      expect(result).toContain("Sub Heading");
-    });
-
-    it("renders h3 headings", () => {
-      const result = formatResponse("### Third Level");
-      expect(result).toContain("Third Level");
-    });
-
-    it("renders unordered list items with bullet", () => {
-      const result = formatResponse("- item one\n- item two");
-      expect(result).toContain("item one");
-      expect(result).toContain("item two");
-    });
-
-    it("renders * list items", () => {
-      const result = formatResponse("* star item");
-      expect(result).toContain("star item");
-    });
-
-    it("renders + list items", () => {
-      const result = formatResponse("+ plus item");
-      expect(result).toContain("plus item");
-    });
-
-    it("renders ordered list items", () => {
-      const result = formatResponse("1. first\n2. second");
-      expect(result).toContain("first");
-      expect(result).toContain("second");
-    });
-
-    it("renders code blocks", () => {
-      const result = formatResponse("```bash\nfops doctor\n```");
-      expect(result).toContain("fops doctor");
-    });
-
-    it("renders code blocks with language tag", () => {
-      const result = formatResponse("```python\nprint('hi')\n```");
-      expect(result).toContain("print('hi')");
-    });
-
-    it("renders code blocks without language", () => {
-      const result = formatResponse("```\nplain code\n```");
-      expect(result).toContain("plain code");
-    });
-
-    it("renders blockquotes", () => {
-      const result = formatResponse("> some quote");
-      expect(result).toContain("some quote");
-    });
-
-    it("renders blockquote without space after >", () => {
-      const result = formatResponse(">tight quote");
-      expect(result).toContain("tight quote");
-    });
-
-    it("handles empty text", () => {
-      const result = formatResponse("");
-      expect(result).toContain("⏺");
-    });
-
-    it("handles multiple blank lines", () => {
-      const result = formatResponse("line1\n\n\nline2");
-      expect(result).toContain("line1");
-      expect(result).toContain("line2");
-    });
-
-    it("renders inline bold", () => {
-      const result = formatResponse("this is **bold** text");
-      expect(result).toContain("bold");
-    });
-
-    it("renders inline italic", () => {
-      const result = formatResponse("this is *italic* text");
-      expect(result).toContain("italic");
-    });
-
-    it("renders inline code", () => {
-      const result = formatResponse("run `fops up` now");
-      expect(result).toContain("fops up");
-    });
-
-    it("indents subsequent lines with spaces", () => {
-      const result = formatResponse("first\nsecond\nthird");
-      const lines = result.split("\n");
-      expect(lines[0]).toMatch(/⏺/);
-      expect(lines[1]).toMatch(/^\s\s/); // indented
-    });
-
-    it("handles multi-line code block correctly", () => {
-      const input = "Before:\n```bash\nline1\nline2\nline3\n```\nAfter.";
-      const result = formatResponse(input);
-      expect(result).toContain("line1");
-      expect(result).toContain("line2");
-      expect(result).toContain("line3");
-      expect(result).toContain("After.");
-    });
-
-    it("handles indented list items", () => {
-      const result = formatResponse("  - indented item");
-      expect(result).toContain("indented item");
-    });
-
-    it("handles mixed content", () => {
-      const input = [
-        "# Title",
-        "Some text with **bold** and `code`.",
-        "",
-        "- item 1",
-        "- item 2",
-        "",
-        "```bash",
-        "fops doctor",
-        "```",
-        "",
-        "> A quote",
-      ].join("\n");
-      const result = formatResponse(input);
-      expect(result).toContain("Title");
-      expect(result).toContain("bold");
-      expect(result).toContain("fops doctor");
-      expect(result).toContain("A quote");
-    });
-  });
-
-  describe("extractSuggestedCommands", () => {
-    it("extracts commands from bash code blocks", () => {
-      const text = "Try running:\n```bash\nfops doctor\n```\nThen:\n```bash\nfops up\n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual(["fops doctor", "fops up"]);
-    });
-
-    it("extracts from sh blocks", () => {
-      const text = "```sh\necho hello\n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual(["echo hello"]);
-    });
-
-    it("returns empty for non-bash blocks", () => {
-      const text = "```json\n{}\n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual([]);
-    });
-
-    it("returns empty for unlabeled code blocks", () => {
-      const text = "```\nsome code\n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual([]);
-    });
-
-    it("returns empty when no code blocks", () => {
-      const cmds = extractSuggestedCommands("just some text");
-      expect(cmds).toEqual([]);
-    });
-
-    it("returns empty for empty string", () => {
-      const cmds = extractSuggestedCommands("");
-      expect(cmds).toEqual([]);
-    });
-
-    it("skips comment-only lines", () => {
-      const text = "```bash\n# this is a comment\nfops status\n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual(["fops status"]);
-    });
-
-    it("takes only first command from multi-line blocks", () => {
-      const text = "```bash\nfops doctor\nfops up\n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual(["fops doctor"]);
-    });
-
-    it("skips blocks where all lines are comments", () => {
-      const text = "```bash\n# just a comment\n# another comment\n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual([]);
-    });
-
-    it("handles BASH uppercase language tag", () => {
-      const text = "```BASH\nfops status\n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual(["fops status"]);
-    });
-
-    it("handles Bash mixed case", () => {
-      const text = "```Bash\nfops logs\n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual(["fops logs"]);
-    });
-
-    it("trims whitespace from commands", () => {
-      const text = "```bash\n  fops doctor  \n```";
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual(["fops doctor"]);
-    });
-
-    it("handles multiple blocks interleaved with text", () => {
-      const text = [
-        "First do this:",
-        "```bash",
-        "fops init",
-        "```",
-        "Then check:",
-        "```bash",
-        "fops doctor",
-        "```",
-        "Finally:",
-        "```bash",
-        "fops up",
-        "```",
-      ].join("\n");
-      const cmds = extractSuggestedCommands(text);
-      expect(cmds).toEqual(["fops init", "fops doctor", "fops up"]);
-    });
-  });
-});

package/src/agent/context.test.js

@@ -1,81 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { FOUNDATION_SYSTEM_PROMPT, getFoundationContextBlock } from "./context.js";
-
-describe("context", () => {
-  describe("FOUNDATION_SYSTEM_PROMPT", () => {
-    it("defines FOPS personality", () => {
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("FOPS");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Foundation Operator");
-    });
-
-    it("includes capabilities", () => {
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Setup & Init");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Operations");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Debugging");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Security");
-    });
-
-    it("lists available commands", () => {
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("fops init");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("fops up");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("fops down");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("fops doctor");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("fops status");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("fops logs");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("fops restart");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("fops login");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("fops chat");
-    });
-
-    it("includes security rules", () => {
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Never output API keys");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Validate file paths");
-    });
-
-    it("includes service ports", () => {
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("9001");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("3002");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("5432");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("9092");
-    });
-
-    it("includes personality traits", () => {
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Terse");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Precise");
-    });
-
-    it("includes setup checklist", () => {
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("Setup Checklist");
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("npm install -g");
-    });
-
-    it("instructs to use fops commands not raw make", () => {
-      expect(FOUNDATION_SYSTEM_PROMPT).toContain("ALWAYS use `fops` commands");
-    });
-  });
-
-  describe("getFoundationContextBlock", () => {
-    it("returns project root message when root is provided", () => {
-      const result = getFoundationContextBlock("/path/to/project");
-      expect(result).toContain("/path/to/project");
-      expect(result).toContain("Project root");
-      expect(result).toContain("Commands run in this directory");
-    });
-
-    it("returns init message when root is null", () => {
-      const result = getFoundationContextBlock(null);
-      expect(result).toContain("fops init");
-      expect(result).toContain("No Foundation project root found");
-    });
-
-    it("returns init message when root is undefined", () => {
-      const result = getFoundationContextBlock(undefined);
-      expect(result).toContain("fops init");
-    });
-
-    it("returns init message when root is empty string", () => {
-      const result = getFoundationContextBlock("");
-      expect(result).toContain("fops init");
-    });
-  });
-});

package/src/agent/llm.test.js

@@ -1,139 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("execa", () => ({
-  execa: vi.fn(),
-  execaSync: vi.fn(),
-}));
-
-vi.mock("../auth/index.js", () => ({
-  resolveAnthropicApiKey: vi.fn(() => null),
-  resolveOpenAiApiKey: vi.fn(() => null),
-  readClaudeCodeKeychain: vi.fn(() => null),
-}));
-
-vi.mock("../ui/index.js", () => ({
-  renderSpinner: vi.fn(() => ({ stop: vi.fn() })),
-}));
-
-const { execa, execaSync } = await import("execa");
-const { readClaudeCodeKeychain } = await import("../auth/index.js");
-const { hasClaudeCode, hasClaudeCodeAuth, runViaClaudeCode, streamViaClaudeCode } = await import("./llm.js");
-
-describe("llm", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("hasClaudeCode", () => {
-    it("returns true when claude is on PATH", () => {
-      execaSync.mockReturnValue({ stdout: "/usr/local/bin/claude" });
-      expect(hasClaudeCode()).toBe(true);
-    });
-
-    it("returns false when claude is not found", () => {
-      execaSync.mockImplementation(() => { throw new Error("not found"); });
-      expect(hasClaudeCode()).toBe(false);
-    });
-
-    it("calls which claude", () => {
-      execaSync.mockReturnValue({ stdout: "" });
-      hasClaudeCode();
-      expect(execaSync).toHaveBeenCalledWith("which", ["claude"]);
-    });
-  });
-
-  describe("hasClaudeCodeAuth", () => {
-    it("returns true when keychain has accessToken", () => {
-      readClaudeCodeKeychain.mockReturnValue({ accessToken: "sk-ant-oat01-xxx" });
-      expect(hasClaudeCodeAuth()).toBe(true);
-    });
-
-    it("returns false when keychain returns null", () => {
-      readClaudeCodeKeychain.mockReturnValue(null);
-      expect(hasClaudeCodeAuth()).toBe(false);
-    });
-
-    it("returns false when accessToken is missing", () => {
-      readClaudeCodeKeychain.mockReturnValue({ refreshToken: "rt-xxx" });
-      expect(hasClaudeCodeAuth()).toBe(false);
-    });
-
-    it("returns false when accessToken is empty", () => {
-      readClaudeCodeKeychain.mockReturnValue({ accessToken: "" });
-      expect(hasClaudeCodeAuth()).toBe(false);
-    });
-
-    it("returns false when keychain returns empty object", () => {
-      readClaudeCodeKeychain.mockReturnValue({});
-      expect(hasClaudeCodeAuth()).toBe(false);
-    });
-  });
-
-  describe("runViaClaudeCode", () => {
-    it("calls claude CLI with prompt and system prompt", async () => {
-      execa.mockResolvedValue({ stdout: "response text" });
-      const result = await runViaClaudeCode("my prompt", "system prompt");
-      expect(result).toBe("response text");
-      expect(execa).toHaveBeenCalledWith(
-        "claude",
-        ["-p", "--no-session-persistence", "--append-system-prompt", "system prompt"],
-        expect.objectContaining({ input: "my prompt", encoding: "utf8" })
-      );
-    });
-
-    it("omits system prompt flag when not provided", async () => {
-      execa.mockResolvedValue({ stdout: "response" });
-      await runViaClaudeCode("prompt", null);
-      const args = execa.mock.calls[0][1];
-      expect(args).not.toContain("--append-system-prompt");
-    });
-
-    it("returns empty string when stdout is empty", async () => {
-      execa.mockResolvedValue({ stdout: "" });
-      const result = await runViaClaudeCode("prompt", "sys");
-      expect(result).toBe("");
-    });
-
-    it("returns empty string when stdout is null", async () => {
-      execa.mockResolvedValue({ stdout: null });
-      const result = await runViaClaudeCode("prompt", "sys");
-      expect(result).toBe("");
-    });
-  });
-
-  describe("streamViaClaudeCode", () => {
-    it("accumulates chunks and returns full text", async () => {
-      const { EventEmitter } = await import("node:events");
-      const mockStdout = new EventEmitter();
-      const mockProc = Promise.resolve();
-      mockProc.stdout = mockStdout;
-
-      execa.mockReturnValue(mockProc);
-
-      const chunks = [];
-      const resultPromise = streamViaClaudeCode("prompt", "sys", (chunk) => chunks.push(chunk));
-
-      mockStdout.emit("data", Buffer.from("hello "));
-      mockStdout.emit("data", Buffer.from("world"));
-
-      const result = await resultPromise;
-      expect(result).toBe("hello world");
-      expect(chunks).toEqual(["hello ", "world"]);
-    });
-
-    it("works without onChunk callback", async () => {
-      const { EventEmitter } = await import("node:events");
-      const mockStdout = new EventEmitter();
-      const mockProc = Promise.resolve();
-      mockProc.stdout = mockStdout;
-
-      execa.mockReturnValue(mockProc);
-
-      const resultPromise = streamViaClaudeCode("prompt", "sys");
-      mockStdout.emit("data", Buffer.from("data"));
-
-      const result = await resultPromise;
-      expect(result).toBe("data");
-    });
-  });
-});

package/src/auth/keychain.test.js

@@ -1,185 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-
-vi.mock("execa", () => ({
-  execaSync: vi.fn(),
-}));
-
-const { execaSync } = await import("execa");
-const { readClaudeCodeKeychain, saveClaudeCodeKeychain } = await import("./keychain.js");
-
-describe("auth/keychain", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("readClaudeCodeKeychain", () => {
-    it("returns null on non-darwin platforms", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "linux" });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null on win32", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "win32" });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      expect(execaSync).not.toHaveBeenCalled();
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns tokens on darwin when keychain has data", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({
-        stdout: JSON.stringify({
-          claudeAiOauth: {
-            accessToken: "sk-ant-oat01-test",
-            refreshToken: "rt-test",
-          },
-        }),
-      });
-      const result = readClaudeCodeKeychain();
-      expect(result).toEqual({
-        accessToken: "sk-ant-oat01-test",
-        refreshToken: "rt-test",
-      });
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null refreshToken when not in keychain data", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({
-        stdout: JSON.stringify({
-          claudeAiOauth: {
-            accessToken: "sk-ant-oat01-test",
-          },
-        }),
-      });
-      const result = readClaudeCodeKeychain();
-      expect(result).toEqual({
-        accessToken: "sk-ant-oat01-test",
-        refreshToken: null,
-      });
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null on darwin when keychain throws", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockImplementation(() => { throw new Error("not found"); });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null when keychain data has no claudeAiOauth", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({ stdout: JSON.stringify({ other: "data" }) });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns null when stdout is not valid JSON", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({ stdout: "not json" });
-      expect(readClaudeCodeKeychain()).toBe(null);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("calls security find-generic-password on darwin", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({ stdout: "{}" });
-      readClaudeCodeKeychain();
-      expect(execaSync).toHaveBeenCalledWith(
-        "security",
-        ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
-        { encoding: "utf8" }
-      );
-      Object.defineProperty(process, "platform", { value: original });
-    });
-  });
-
-  describe("saveClaudeCodeKeychain", () => {
-    it("returns false on non-darwin platforms", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "linux" });
-      expect(saveClaudeCodeKeychain("token")).toBe(false);
-      expect(execaSync).not.toHaveBeenCalled();
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("calls security commands on darwin", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({});
-      const result = saveClaudeCodeKeychain("access-token", "refresh-token");
-      expect(result).toBe(true);
-      expect(execaSync).toHaveBeenCalledWith(
-        "security",
-        expect.arrayContaining(["delete-generic-password"])
-      );
-      expect(execaSync).toHaveBeenCalledWith(
-        "security",
-        expect.arrayContaining(["add-generic-password"])
-      );
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("succeeds even when delete fails (no existing entry)", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      let callCount = 0;
-      execaSync.mockImplementation((_cmd, args) => {
-        if (args.includes("delete-generic-password")) {
-          throw new Error("item not found");
-        }
-        return {};
-      });
-      const result = saveClaudeCodeKeychain("access-token");
-      expect(result).toBe(true);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("returns false when add-generic-password fails", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockImplementation((_cmd, args) => {
-        if (args.includes("add-generic-password")) {
-          throw new Error("keychain locked");
-        }
-        return {};
-      });
-      const result = saveClaudeCodeKeychain("token");
-      expect(result).toBe(false);
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("saves without refreshToken when not provided", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({});
-      saveClaudeCodeKeychain("access-only");
-      const addCall = execaSync.mock.calls.find((c) => c[1].includes("add-generic-password"));
-      const data = JSON.parse(addCall[1][addCall[1].indexOf("-w") + 1]);
-      expect(data.claudeAiOauth.accessToken).toBe("access-only");
-      expect(data.claudeAiOauth.refreshToken).toBeUndefined();
-      Object.defineProperty(process, "platform", { value: original });
-    });
-
-    it("includes refreshToken when provided", () => {
-      const original = process.platform;
-      Object.defineProperty(process, "platform", { value: "darwin" });
-      execaSync.mockReturnValue({});
-      saveClaudeCodeKeychain("access", "refresh");
-      const addCall = execaSync.mock.calls.find((c) => c[1].includes("add-generic-password"));
-      const data = JSON.parse(addCall[1][addCall[1].indexOf("-w") + 1]);
-      expect(data.claudeAiOauth.accessToken).toBe("access");
-      expect(data.claudeAiOauth.refreshToken).toBe("refresh");
-      Object.defineProperty(process, "platform", { value: original });
-    });
-  });
-});