@meshxdata/fops 0.0.1

package/src/agent/agent.test.js

@@ -0,0 +1,233 @@
+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.js

@@ -0,0 +1,143 @@
+import fs from "node:fs";
+import path from "node:path";
+import { execa } from "execa";
+import { loadSkills } from "../plugins/index.js";
+
+export const FOUNDATION_SYSTEM_PROMPT = `You are FOPS — the Foundation Operator. Think of yourself as the system admin who actually knows what they're doing. You're direct, no-BS, slightly irreverent. You don't sugarcoat problems — you diagnose and fix them. Channel the energy of someone who lives in the terminal and sees the matrix in docker logs.
+
+## Personality
+- Terse. Precise. Slightly amused by broken things.
+- Use short sentences. No corporate fluff.
+- When something is broken, say what's broken and how to fix it. No preambles.
+- Treat the user like a peer, not a customer.
+
+## Capabilities
+- **Setup & Init**: Prerequisites, environment config, first-run setup
+- **Operations**: Start/stop services, status, logs, diagnostics
+- **Debugging**: Troubleshoot issues, analyze logs, suggest fixes
+- **Security**: Validate configs, check credentials safely (never log secrets)
+
+## Commands
+When suggesting commands, ALWAYS use \`fops\` commands, not raw \`make\` or \`git clone\`. Output each in its own fenced block.
+
+**Always suggest 2–3 commands** so the user can pick. For example, if someone asks "what's running?", suggest both a status check and a diagnostic:
+\`\`\`bash
+fops status
+\`\`\`
+\`\`\`bash
+fops doctor
+\`\`\`
+
+If a single action is needed, pair it with a follow-up (e.g. restart + logs, doctor + up).
+
+## Available fops Commands
+- fops init — clone repos, bootstrap environment
+- fops up / fops down — start/stop the stack
+- fops restart — restart all or specific services
+- fops status — show running containers
+- fops logs [service] — tail logs
+- fops doctor — run diagnostics
+- fops login — authenticate with AWS/ECR
+- fops agent / fops chat — talk to me
+
+## Services & Ports
+Backend:9001, Frontend:3002, Storage:9002, Trino:8081, OPA:8181, Kafka:9092, Postgres:5432, Hive:9083, Vault:18201
+
+## Setup Checklist (for new users)
+1. Install prerequisites: git, docker, node >= 18, aws cli (optional)
+2. \`npm install -g @meshxdata/fops\`
+3. \`fops init\` — clones repos, sets up .env
+4. \`fops up\` — boots the stack
+5. \`fops doctor\` — verifies everything is healthy
+
+## Security Rules
+- Never output API keys, passwords, or tokens in responses
+- Suggest secure alternatives when users try unsafe operations
+- Validate file paths before suggesting file operations`;
+
+export function getFoundationContextBlock(root) {
+  if (!root) return "No Foundation project root found. User may need to run fops init.";
+  return `Project root: ${root}. Commands run in this directory.`;
+}
+
+export async function gatherStackContext(root) {
+  const parts = [getFoundationContextBlock(root)];
+
+  // Check Docker status (only if we have a project root)
+  if (root) {
+    try {
+      const { stdout: psOut } = await execa("docker", ["compose", "ps", "--format", "json"], { cwd: root, reject: false, timeout: 5000 });
+      if (psOut && psOut.trim()) {
+        const lines = psOut.trim().split("\n").filter(Boolean);
+        const services = lines.map((line) => {
+          try {
+            const o = JSON.parse(line);
+            return `${o.Name || o.name || "?"}: ${o.State || o.Status || "?"}`;
+          } catch {
+            return null;
+          }
+        }).filter(Boolean);
+        if (services.length) parts.push("Running containers:\n" + services.join("\n"));
+        else parts.push("No containers running.");
+      }
+    } catch {
+      parts.push("Docker: not available or not running.");
+    }
+  }
+
+  // Check image ages
+  if (root) {
+    try {
+      const { stdout: imgOut } = await execa("docker", ["compose", "images", "--format", "json"], { cwd: root, reject: false, timeout: 5000 });
+      if (imgOut?.trim()) {
+        const ages = [];
+        for (const line of imgOut.trim().split("\n").filter(Boolean)) {
+          try {
+            const img = JSON.parse(line);
+            const id = img.ID || img.id || "";
+            const repo = img.Repository || img.repository || "";
+            const tag = img.Tag || img.tag || "";
+            if (!id) continue;
+            const { stdout: created } = await execa("docker", ["image", "inspect", id, "--format", "{{.Created}}"], { reject: false, timeout: 3000 });
+            if (created?.trim()) {
+              const days = Math.floor((Date.now() - new Date(created.trim()).getTime()) / 86400000);
+              const name = `${repo}:${tag}`.replace(/^:|:$/g, "") || id.slice(0, 12);
+              ages.push(`${name}: ${days}d old`);
+            }
+          } catch {}
+        }
+        if (ages.length) parts.push("Image ages:\n" + ages.join("\n"));
+      }
+    } catch {}
+  }
+
+  // Check prerequisites (each wrapped individually so one failure doesn't kill the rest)
+  const prereqs = [];
+  try { await execa("git", ["--version"], { reject: false, timeout: 3000 }); prereqs.push("git: ✓"); } catch { prereqs.push("git: ✗"); }
+  try { await execa("docker", ["info"], { reject: false, timeout: 5000 }); prereqs.push("docker: ✓"); } catch { prereqs.push("docker: ✗"); }
+  try { await execa("aws", ["--version"], { reject: false, timeout: 3000 }); prereqs.push("aws-cli: ✓"); } catch { prereqs.push("aws-cli: ✗ (optional)"); }
+  parts.push("Prerequisites: " + prereqs.join(", "));
+
+  // Check for .env file
+  if (root) {
+    const envPath = path.join(root, ".env");
+    const envExamplePath = path.join(root, ".env.example");
+    if (fs.existsSync(envPath)) {
+      parts.push(".env: configured");
+    } else if (fs.existsSync(envExamplePath)) {
+      parts.push(".env: not configured (run 'fops setup' or 'cp .env.example .env')");
+    }
+  }
+
+  // Inject plugin skills into context
+  try {
+    const skills = await loadSkills();
+    if (skills.length) {
+      parts.push("## Additional Skills\n" + skills.map((s) => s.content).join("\n\n"));
+    }
+  } catch {
+    // skip if skill loading fails
+  }
+
+  return parts.join("\n\n");
+}

package/src/agent/context.test.js

@@ -0,0 +1,81 @@
+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/index.js

@@ -0,0 +1,2 @@
+export { runAgentSingleTurn, runAgentInteractive } from "./agent.js";
+export { gatherStackContext } from "./context.js";

package/src/agent/llm.js

@@ -0,0 +1,127 @@
+import chalk from "chalk";
+import { execa, execaSync } from "execa";
+import { resolveAnthropicApiKey, resolveOpenAiApiKey, readClaudeCodeKeychain } from "../auth/index.js";
+import { renderSpinner } from "../ui/index.js";
+
+// Check if Claude Code CLI is available
+export function hasClaudeCode() {
+  try {
+    execaSync("which", ["claude"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Check if user has Claude Code OAuth credentials
+export function hasClaudeCodeAuth() {
+  const creds = readClaudeCodeKeychain();
+  return !!creds?.accessToken;
+}
+
+/**
+ * Build a single prompt string from the full conversation history
+ * so Claude Code preserves context between turns.
+ */
+function buildConversationPrompt(messages) {
+  if (messages.length <= 1) {
+    return messages[0]?.content || "";
+  }
+
+  return messages.map((m) => {
+    const role = m.role === "user" ? "User" : "Assistant";
+    return `${role}: ${m.content}`;
+  }).join("\n\n");
+}
+
+/**
+ * Run a prompt through Claude Code CLI (uses OAuth auth)
+ */
+export async function runViaClaudeCode(prompt, systemPrompt) {
+  const args = ["-p", "--no-session-persistence"];
+  if (systemPrompt) {
+    args.push("--append-system-prompt", systemPrompt);
+  }
+
+  const { stdout } = await execa("claude", args, {
+    input: prompt,
+    encoding: "utf8",
+    reject: false,
+  });
+
+  return stdout || "";
+}
+
+/**
+ * Stream response via Claude Code CLI with thinking display
+ */
+export async function streamViaClaudeCode(prompt, systemPrompt, onChunk, onThinking) {
+  const args = ["-p", "--no-session-persistence"];
+  if (systemPrompt) {
+    args.push("--append-system-prompt", systemPrompt);
+  }
+
+  const proc = execa("claude", args, {
+    input: prompt,
+    encoding: "utf8",
+    reject: false,
+  });
+
+  let fullText = "";
+
+  proc.stdout.on("data", (chunk) => {
+    const text = chunk.toString();
+    fullText += text;
+    if (onChunk) onChunk(text);
+  });
+
+  await proc;
+  return fullText;
+}
+
+export async function streamAssistantReply(root, messages, systemContent, opts) {
+  const useClaudeCode = hasClaudeCode() && hasClaudeCodeAuth();
+  const anthropicKey = resolveAnthropicApiKey();
+  const openaiKey = resolveOpenAiApiKey();
+  const model = opts.model || (anthropicKey ? "claude-sonnet-4-20250514" : "gpt-4o-mini");
+
+  let fullText = "";
+  const spinner = renderSpinner();
+
+  try {
+    if (useClaudeCode) {
+      // Build full conversation prompt so context is preserved between turns
+      const prompt = buildConversationPrompt(messages);
+      fullText = await streamViaClaudeCode(prompt, systemContent);
+    } else if (anthropicKey) {
+      const { default: Anthropic } = await import("@anthropic-ai/sdk");
+      const client = new Anthropic({ apiKey: anthropicKey });
+      const stream = await client.messages.create({
+        model, max_tokens: 2048, system: systemContent, messages, stream: true,
+      });
+      for await (const event of stream) {
+        if (event.type === "content_block_delta" && event.delta?.type === "text_delta" && event.delta.text) {
+          fullText += event.delta.text;
+        }
+      }
+    } else if (openaiKey) {
+      const OpenAI = (await import("openai")).default;
+      const client = new OpenAI({ apiKey: openaiKey });
+      const stream = await client.chat.completions.create({
+        model, max_tokens: 2048,
+        messages: [{ role: "system", content: systemContent }, ...messages],
+        stream: true,
+      });
+      for await (const chunk of stream) {
+        const delta = chunk.choices?.[0]?.delta?.content;
+        if (delta) fullText += delta;
+      }
+    } else {
+      throw new Error("No API key (use ANTHROPIC_API_KEY, OPENAI_API_KEY, or ~/.claude auth)");
+    }
+  } finally {
+    spinner.stop();
+  }
+
+  return fullText;
+}