@meshxdata/fops 0.0.1 → 0.0.3

package/src/ui/spinner.js

@@ -89,8 +89,9 @@ export function renderSpinner(message) {
 
 /**
  * Thinking display component - shows what the agent is doing
+ * Displays reasoning text (thinking) and response preview separately
  */
-function ThinkingDisplay({ status, detail, content }) {
+function ThinkingDisplay({ status, detail, thinking, content }) {
   const [verb, setVerb] = useState(getRandomVerb());
   const [frame, setFrame] = useState(0);
 
@@ -106,6 +107,20 @@ function ThinkingDisplay({ status, detail, content }) {
     return () => clearInterval(interval);
   }, []);
 
+  // Show last 4 non-empty lines of thinking text
+  const thinkingPreview = (() => {
+    if (!thinking) return null;
+    const lines = thinking.split("\n").filter(l => l.trim());
+    return lines.slice(-4).join("\n");
+  })();
+
+  // Show last 4 non-empty lines of response content
+  const contentPreview = (() => {
+    if (!content) return null;
+    const lines = content.split("\n").filter(l => l.trim());
+    return lines.slice(-4).join("\n");
+  })();
+
   return h(Box, { flexDirection: "column" },
     // Status line with spinner
     h(Box, null,
@@ -113,37 +128,40 @@ function ThinkingDisplay({ status, detail, content }) {
       h(Text, { color: "yellow" }, ` ${status || verb}... `),
       detail && h(Text, { dimColor: true }, detail)
     ),
-    // Content preview (truncated)
-    content && h(Box, { marginTop: 1, marginLeft: 2 },
-      h(Text, { dimColor: true },
-        content.length > 100 ? content.slice(0, 100) + "..." : content
-      )
+    // Thinking preview (dimmed, italic)
+    thinkingPreview && h(Box, { marginLeft: 2 },
+      h(Text, { dimColor: true }, thinkingPreview)
+    ),
+    // Response content preview
+    contentPreview && h(Box, { marginLeft: 2 },
+      h(Text, { color: "gray" }, contentPreview)
     )
   );
 }
 
 // State for thinking display
-let thinkingState = { status: "", detail: "", content: "", rerender: null };
+let thinkingState = { status: "", detail: "", thinking: "", content: "", rerender: null };
 
 /**
  * Render thinking display
- * Returns controls to update status and content
+ * Returns controls to update status, thinking text, and content
  */
 export function renderThinking() {
-  thinkingState = { status: "", detail: "", content: "" };
+  thinkingState = { status: "", detail: "", thinking: "", content: "" };
 
   const update = () => {
     if (thinkingState.rerender) {
       thinkingState.rerender(h(ThinkingDisplay, {
         status: thinkingState.status,
         detail: thinkingState.detail,
+        thinking: thinkingState.thinking,
         content: thinkingState.content,
       }));
     }
   };
 
   const { rerender, unmount, clear } = render(
-    h(ThinkingDisplay, { status: "", detail: "", content: "" })
+    h(ThinkingDisplay, { status: "", detail: "", thinking: "", content: "" })
   );
   thinkingState.rerender = rerender;
 
@@ -153,6 +171,14 @@ export function renderThinking() {
       thinkingState.detail = detail;
       update();
     },
+    setThinking: (text) => {
+      thinkingState.thinking = text;
+      update();
+    },
+    appendThinking: (text) => {
+      thinkingState.thinking += text;
+      update();
+    },
     setContent: (content) => {
       thinkingState.content = content;
       update();

package/STRUCTURE.md

@@ -1,43 +0,0 @@
-# Foundation CLI — Project structure
-
-Long-term layout for a single package inside the foundation-compose repo. No git submodules required; the CLI lives in `foundation-cli/` and is versioned with the repo.
-
-## Layout
-
-```
-foundation-cli/
-├── foundation.mjs          # Entry point: parses argv, registers commands, runs
-├── package.json
-├── README.md
-├── STRUCTURE.md            # This file
-├── install.sh              # Optional curl | bash installer
-└── src/
-    ├── config.js           # PKG, CLI_BRAND, printFoundationBanner
-    ├── project.js          # rootDir, requireRoot, isFoundationRoot, findComposeRootUp
-    ├── shell.js            # make(), dockerCompose()
-    ├── auth.js             # resolveAnthropicApiKey, resolveOpenAiApiKey, authHelp, offerClaudeLogin
-    ├── setup.js            # runSetup, runInitWizard, checkEcrRepos
-    ├── agent.js            # gatherStackContext, runAgentSingleTurn, runAgentInteractive, streaming
-    ├── doctor.js           # runDoctor (checks + optional --fix)
-    └── commands/
-        └── index.js       # registerCommands(program) — wires all CLI commands
-```
-
-## Conventions
-
-- **Single entry**: `foundation.mjs` is the only file executed; it imports `src/commands/index.js` and calls `registerCommands(program)`.
-- **No circular imports**: Flow is entry → commands → lib (config, project, shell, auth, setup, agent, doctor). Lib modules do not import commands.
-- **ESM only**: `"type": "module"` in package.json; all sources use `import`/`export`.
-- **Shared helpers**: Project root detection and `make`/docker are in `project.js` and `shell.js` so every command reuses the same semantics.
-
-## Adding a command
-
-1. Implement logic in the appropriate `src/*.js` (or a new one if it’s a new domain).
-2. In `src/commands/index.js`, add a `program.command(...).action(...)` that calls your function and uses `requireRoot(program)` or `rootDir()` as needed.
-
-## Optional: separate repo (submodule)
-
-If you later move the CLI to its own repo and add it as a submodule under `foundation-compose/foundation-cli`:
-
-- Keep this same layout inside the submodule.
-- Root `setup.sh` and docs can still say “run `node foundation-cli/foundation.mjs`” or “`npx foundation`” if the package is published.

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");
-    });
-  });
-});