joonecli 0.1.0

package/src/__tests__/config.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+// We will import these once they exist — test-first.
+import { loadConfig, saveConfig, DEFAULT_CONFIG } from "../cli/config.js";
+
+describe("Config Manager", () => {
+  // Use a temp directory so we never touch the real ~/.joone
+  let tempDir: string;
+  let configPath: string;
+  let savedAnthropicKey: string | undefined;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "joone-test-"));
+    configPath = path.join(tempDir, "config.json");
+    // Isolate from vitest.config.ts env vars
+    savedAnthropicKey = process.env.ANTHROPIC_API_KEY;
+    delete process.env.ANTHROPIC_API_KEY;
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    // Restore env var
+    if (savedAnthropicKey !== undefined) {
+      process.env.ANTHROPIC_API_KEY = savedAnthropicKey;
+    }
+  });
+
+  // ─── RED Test #1: loadConfig returns defaults when file doesn't exist ───
+
+  it("returns default config when config file does not exist", () => {
+    const config = loadConfig(configPath);
+
+    expect(config.provider).toBe("anthropic");
+    expect(config.model).toBe("claude-sonnet-4-20250514");
+    expect(config.apiKey).toBeUndefined();
+    expect(config.maxTokens).toBe(4096);
+    expect(config.temperature).toBe(0);
+    expect(config.streaming).toBe(true);
+  });
+
+  // ─── RED Test #2: saveConfig roundtrips with loadConfig ───
+
+  it("saves config to disk and loads it back correctly", () => {
+    const custom = {
+      ...DEFAULT_CONFIG,
+      provider: "openai",
+      model: "gpt-4o",
+      apiKey: "sk-test-key-123",
+      streaming: false,
+    };
+
+    saveConfig(configPath, custom);
+
+    // File should exist now
+    expect(fs.existsSync(configPath)).toBe(true);
+
+    // Load it back — should match what was saved
+    const loaded = loadConfig(configPath);
+    expect(loaded.provider).toBe("openai");
+    expect(loaded.model).toBe("gpt-4o");
+    expect(loaded.apiKey).toBe("sk-test-key-123");
+    expect(loaded.streaming).toBe(false);
+    // Fields we didn't override should keep defaults
+    expect(loaded.maxTokens).toBe(4096);
+    expect(loaded.temperature).toBe(0);
+  });
+
+  // ─── RED Test #3: loadConfig uses env var fallback for API key ───
+
+  it("falls back to ANTHROPIC_API_KEY env var when apiKey is missing from config", () => {
+    // Save a config WITHOUT an apiKey
+    const noKeyConfig = {
+      ...DEFAULT_CONFIG,
+      provider: "anthropic",
+    };
+    saveConfig(configPath, noKeyConfig);
+
+    // Set the env var
+    const originalEnv = process.env.ANTHROPIC_API_KEY;
+    process.env.ANTHROPIC_API_KEY = "sk-ant-from-env";
+
+    try {
+      const config = loadConfig(configPath);
+      expect(config.apiKey).toBe("sk-ant-from-env");
+    } finally {
+      // Restore env
+      if (originalEnv === undefined) {
+        delete process.env.ANTHROPIC_API_KEY;
+      } else {
+        process.env.ANTHROPIC_API_KEY = originalEnv;
+      }
+    }
+  });
+});

package/src/__tests__/m55.test.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { BrowserTool } from "../tools/browser.js";
+import { WebSearchTool, bindValyuApiKey } from "../tools/webSearch.js";
+import { SkillLoader } from "../skills/loader.js";
+import {
+  SearchSkillsTool,
+  LoadSkillTool,
+  bindSkillLoader,
+} from "../skills/tools.js";
+import { ToolRouter, ToolTarget } from "../tools/router.js";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 5.5a: Browser Tool
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("BrowserTool", () => {
+  // ─── Test #70: Builds navigate command ───
+
+  it("has the correct schema with all supported actions", () => {
+    expect(BrowserTool.name).toBe("browser");
+    expect(BrowserTool.schema.properties.action.enum).toContain("navigate");
+    expect(BrowserTool.schema.properties.action.enum).toContain("snapshot");
+    expect(BrowserTool.schema.properties.action.enum).toContain("click");
+    expect(BrowserTool.schema.properties.action.enum).toContain("type");
+    expect(BrowserTool.schema.properties.action.enum).toContain("screenshot");
+    expect(BrowserTool.schema.properties.action.enum).toContain("scroll");
+  });
+
+  // ─── Test #71: Rejects without sandbox ───
+
+  it("throws when sandbox is not active", async () => {
+    const result = await BrowserTool.execute({ action: "navigate", url: "https://example.com" });
+    expect(result.isError).toBe(true);
+    expect(result.content).toMatch(/sandbox/i);
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 5.5b: Web Search Tool
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("WebSearchTool", () => {
+  // ─── Test #72: Returns error if no API key ───
+
+  it("returns error when API key is not configured", async () => {
+    bindValyuApiKey(undefined);
+    const result = await WebSearchTool.execute({ query: "test" });
+
+    expect(result.content).toMatch(/api key not configured/i);
+  });
+
+  // ─── Test #73: Schema includes all sources ───
+
+  it("schema includes all search sources", () => {
+    const sources = WebSearchTool.schema.properties.source.enum;
+
+    expect(sources).toContain("web");
+    expect(sources).toContain("papers");
+    expect(sources).toContain("finance");
+    expect(sources).toContain("patents");
+    expect(sources).toContain("sec");
+    expect(sources).toContain("companies");
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// 5.5c: Skills System
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("SkillLoader", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "joone-skills-test-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  const createSkill = (
+    dir: string,
+    name: string,
+    content: string
+  ): void => {
+    const skillDir = path.join(dir, name);
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(path.join(skillDir, "SKILL.md"), content);
+  };
+
+  // ─── Test #74: Discovers skills from project root ───
+
+  it("discovers skills from a directory", () => {
+    const skillsDir = path.join(tmpDir, "skills");
+    createSkill(
+      skillsDir,
+      "deploy",
+      "---\nname: deploy\ndescription: Deploy to Vercel\n---\n## Steps\n1. Run vercel deploy"
+    );
+
+    const loader = new SkillLoader(tmpDir);
+    const skills = loader.discoverSkills();
+
+    expect(skills.length).toBeGreaterThanOrEqual(1);
+    const deploy = skills.find((s) => s.name === "deploy");
+    expect(deploy).toBeDefined();
+    expect(deploy!.description).toBe("Deploy to Vercel");
+    expect(deploy!.source).toBe("project");
+  });
+
+  // ─── Test #75: Parses YAML frontmatter ───
+
+  it("parses YAML frontmatter correctly", () => {
+    const loader = new SkillLoader(tmpDir);
+    const result = loader.parseFrontmatter(
+      "---\nname: test-skill\ndescription: A test skill\n---\n# Instructions"
+    );
+
+    expect(result.name).toBe("test-skill");
+    expect(result.description).toBe("A test skill");
+  });
+
+  // ─── Test #76: Project skills override user skills with same name ───
+
+  it("project skills override user-level skills with the same name", () => {
+    // Create user-level skill in the mocked home directory (tmpDir)
+    const userSkillsDir = path.join(tmpDir, ".joone", "skills");
+    createSkill(
+      userSkillsDir,
+      "deploy",
+      "---\nname: deploy\ndescription: User deploy\n---\n"
+    );
+
+    // Create project-level skill
+    const projectSkillsDir = path.join(tmpDir, "skills");
+    createSkill(
+      projectSkillsDir,
+      "deploy",
+      "---\nname: deploy\ndescription: Project deploy\n---\n"
+    );
+
+    // Pass tmpDir as both projectRoot and userHome
+    const loader = new SkillLoader(tmpDir, tmpDir);
+    const skills = loader.discoverSkills();
+
+    const deploy = skills.find((s) => s.name === "deploy");
+    expect(deploy).toBeDefined();
+    expect(deploy!.source).toBe("project");
+    expect(deploy!.description).toBe("Project deploy");
+
+    // Ensure we only discovered one deploy skill
+    const deployCount = skills.filter((s) => s.name === "deploy").length;
+    expect(deployCount).toBe(1);
+  });
+
+  // ─── Test #77: loadSkill reads full content ───
+
+  it("loads the full content of a skill", () => {
+    const skillsDir = path.join(tmpDir, "skills");
+    const content =
+      "---\nname: tdd\ndescription: Test-driven development\n---\n## Red-Green-Refactor\n1. Write failing test";
+    createSkill(skillsDir, "tdd", content);
+
+    const loader = new SkillLoader(tmpDir);
+    const loaded = loader.loadSkill("tdd");
+
+    expect(loaded).toBe(content);
+  });
+});
+
+describe("Skills Tools", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "joone-skills-tools-test-"));
+
+    const skillsDir = path.join(tmpDir, "skills");
+    const skillDir = path.join(skillsDir, "deploy");
+    fs.mkdirSync(skillDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(skillDir, "SKILL.md"),
+      "---\nname: deploy\ndescription: Deploy to production\n---\n## Steps"
+    );
+
+    bindSkillLoader(new SkillLoader(tmpDir));
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // ─── Test #78: search_skills returns matching skills ───
+
+  it("search_skills finds matching skills", async () => {
+    const result = await SearchSkillsTool.execute({ query: "deploy" });
+
+    expect(result.content).toContain("deploy");
+    expect(result.content).toContain("production");
+  });
+
+  // ─── Test #79: load_skill reads full content ───
+
+  it("load_skill returns the full SKILL.md content", async () => {
+    const result = await LoadSkillTool.execute({ name: "deploy" });
+
+    expect(result.content).toContain("## Steps");
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Routing
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("ToolRouter (M5.5 additions)", () => {
+  const router = new ToolRouter();
+
+  // ─── Test #80: Browser routes to sandbox ───
+
+  it("routes browser to sandbox", () => {
+    expect(router.getTarget("browser")).toBe(ToolTarget.SANDBOX);
+  });
+
+  // ─── Test #81: web_search routes to host ───
+
+  it("routes web_search to host", () => {
+    expect(router.getTarget("web_search")).toBe(ToolTarget.HOST);
+  });
+
+  // ─── Test #82: skills tools route to host ───
+
+  it("routes search_skills and load_skill to host", () => {
+    expect(router.getTarget("search_skills")).toBe(ToolTarget.HOST);
+    expect(router.getTarget("load_skill")).toBe(ToolTarget.HOST);
+  });
+});

package/src/__tests__/middleware.test.ts

@@ -0,0 +1,219 @@
+import { describe, it, expect, vi } from "vitest";
+import { MiddlewarePipeline } from "../middleware/pipeline.js";
+import { ToolCallContext, ToolMiddleware } from "../middleware/types.js";
+import { LoopDetectionMiddleware } from "../middleware/loopDetection.js";
+import { CommandSanitizerMiddleware } from "../middleware/commandSanitizer.js";
+import { PreCompletionMiddleware } from "../middleware/preCompletion.js";
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// Pipeline Core
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("MiddlewarePipeline", () => {
+  const makeCtx = (overrides?: Partial<ToolCallContext>): ToolCallContext => ({
+    toolName: "bash",
+    args: { command: "echo hello" },
+    callId: "call-1",
+    ...overrides,
+  });
+
+  // ─── Test #44: Runs before/after hooks in order ───
+
+  it("runs before hooks in registration order and after hooks in reverse", async () => {
+    const order: string[] = [];
+
+    const pipeline = new MiddlewarePipeline();
+    pipeline.use({
+      name: "A",
+      before: (ctx) => { order.push("A:before"); return ctx; },
+      after: (_ctx, r) => { order.push("A:after"); return r; },
+    });
+    pipeline.use({
+      name: "B",
+      before: (ctx) => { order.push("B:before"); return ctx; },
+      after: (_ctx, r) => { order.push("B:after"); return r; },
+    });
+
+    const executeFn = vi.fn(async () => ({ content: "result" }));
+    await pipeline.run(makeCtx(), executeFn);
+
+    expect(order).toEqual(["A:before", "B:before", "B:after", "A:after"]);
+    expect(executeFn).toHaveBeenCalledOnce();
+  });
+
+  // ─── Test #45: Short-circuits when before returns string ───
+
+  it("short-circuits and does NOT execute the tool when before returns a string", async () => {
+    const pipeline = new MiddlewarePipeline();
+    pipeline.use({
+      name: "Blocker",
+      before: () => "⚠ Blocked!",
+    });
+
+    const executeFn = vi.fn(async () => ({ content: "should not reach this" }));
+    const result = await pipeline.run(makeCtx(), executeFn);
+
+    expect(result).toBe("⚠ Blocked!");
+    expect(executeFn).not.toHaveBeenCalled();
+  });
+
+  // ─── Test #46: After hooks can transform the result ───
+
+  it("after hooks can transform the tool result", async () => {
+    const pipeline = new MiddlewarePipeline();
+    pipeline.use({
+      name: "Uppercaser",
+      after: (_ctx, result) => { result.content = result.content.toUpperCase(); return result; },
+    });
+
+    const result = await pipeline.run(makeCtx(), async () => ({ content: "hello" }));
+
+    expect(result).toBe("HELLO");
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// LoopDetectionMiddleware
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("LoopDetectionMiddleware", () => {
+  const makeCtx = (cmd = "echo hello"): ToolCallContext => ({
+    toolName: "bash",
+    args: { command: cmd },
+    callId: "call-x",
+  });
+
+  // ─── Test #47: Allows first 2 identical calls ───
+
+  it("allows calls below the threshold", () => {
+    const mw = new LoopDetectionMiddleware(3);
+
+    expect(mw.before(makeCtx())).toEqual(makeCtx());
+    expect(mw.before(makeCtx())).toEqual(makeCtx());
+  });
+
+  // ─── Test #48: Blocks on 3rd identical call ───
+
+  it("blocks on the Nth identical consecutive call", () => {
+    const mw = new LoopDetectionMiddleware(3);
+
+    mw.before(makeCtx());
+    mw.before(makeCtx());
+    const result = mw.before(makeCtx());
+
+    expect(typeof result).toBe("string");
+    expect(result as string).toMatch(/loop detected/i);
+  });
+
+  // ─── Test #49: Resets when args change ───
+
+  it("resets the count when a different call is made", () => {
+    const mw = new LoopDetectionMiddleware(3);
+
+    mw.before(makeCtx("echo a"));
+    mw.before(makeCtx("echo a"));
+    // Different call breaks the streak
+    mw.before(makeCtx("echo b"));
+    // Back to "echo a" — only 1 in a row now
+    const result = mw.before(makeCtx("echo a"));
+
+    expect(typeof result).not.toBe("string");
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// CommandSanitizerMiddleware
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("CommandSanitizerMiddleware", () => {
+  const mw = new CommandSanitizerMiddleware();
+
+  const makeCtx = (cmd: string): ToolCallContext => ({
+    toolName: "bash",
+    args: { command: cmd },
+    callId: "call-x",
+  });
+
+  // ─── Test #50: Blocks rm -rf / ───
+
+  it("blocks rm -rf /", () => {
+    const result = mw.before(makeCtx("rm -rf /"));
+    expect(typeof result).toBe("string");
+    expect(result as string).toMatch(/blocked/i);
+  });
+
+  // ─── Test #51: Blocks interactive commands ───
+
+  it("blocks interactive commands like vim", () => {
+    const result = mw.before(makeCtx("vim src/index.ts"));
+    expect(typeof result).toBe("string");
+    expect(result as string).toMatch(/interactive/i);
+  });
+
+  // ─── Test #52: Allows safe commands ───
+
+  it("allows safe commands through", () => {
+    const result = mw.before(makeCtx("npm test"));
+    expect(result).toEqual(makeCtx("npm test"));
+  });
+
+  // ─── Test #53: Ignores non-bash tools ───
+
+  it("ignores non-bash tool calls entirely", () => {
+    const ctx: ToolCallContext = {
+      toolName: "read_file",
+      args: { path: "/etc/passwd" },
+      callId: "call-x",
+    };
+    expect(mw.before(ctx)).toEqual(ctx);
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// PreCompletionMiddleware
+// ═══════════════════════════════════════════════════════════════════════════════
+
+describe("PreCompletionMiddleware", () => {
+  // ─── Test #54: Blocks completion without tests ───
+
+  it("blocks task_complete when no tests have been run", () => {
+    const mw = new PreCompletionMiddleware();
+
+    const ctx: ToolCallContext = {
+      toolName: "task_complete",
+      args: {},
+      callId: "call-x",
+    };
+    const result = mw.before(ctx);
+
+    expect(typeof result).toBe("string");
+    expect(result as string).toMatch(/must run tests/i);
+  });
+
+  // ─── Test #55: Allows completion after tests ───
+
+  it("allows task_complete after a test command has been run", () => {
+    const mw = new PreCompletionMiddleware();
+
+    // Simulate running tests
+    const testCtx: ToolCallContext = {
+      toolName: "bash",
+      args: { command: "npm test" },
+      callId: "call-1",
+    };
+    mw.before(testCtx);
+    mw.after(testCtx, { content: "tests passed", metadata: { exitCode: 0 }, isError: false });
+
+    expect(mw.hasPassedTests()).toBe(true);
+
+    // Now try completion
+    const completeCtx: ToolCallContext = {
+      toolName: "task_complete",
+      args: {},
+      callId: "call-2",
+    };
+    const result = mw.before(completeCtx);
+
+    expect(result).toEqual(completeCtx);
+  });
+});

package/src/__tests__/modelFactory.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "vitest";
+import { JooneConfig, DEFAULT_CONFIG } from "../cli/config.js";
+import { createModel } from "../cli/modelFactory.js";
+
+describe("Model Factory", () => {
+  // ─── RED Test #4: createModel returns a ChatAnthropic for "anthropic" ───
+
+  it("creates an Anthropic model when provider is 'anthropic'", async () => {
+    const config: JooneConfig = {
+      ...DEFAULT_CONFIG,
+      provider: "anthropic",
+      model: "claude-sonnet-4-20250514",
+      apiKey: "sk-ant-test-key",
+    };
+
+    const model = await createModel(config);
+
+    // The model should have the correct type identifier
+    expect(model).toBeDefined();
+    expect(model.constructor.name).toContain("ChatAnthropic");
+  }, 15000);
+
+  // ─── RED Test #5: createModel returns a ChatOpenAI for "openai" ───
+
+  it("creates an OpenAI model when provider is 'openai'", async () => {
+    const config: JooneConfig = {
+      ...DEFAULT_CONFIG,
+      provider: "openai",
+      model: "gpt-4o",
+      apiKey: "sk-openai-test-key",
+    };
+
+    const model = await createModel(config);
+
+    expect(model).toBeDefined();
+    expect(model.constructor.name).toContain("ChatOpenAI");
+  }, 15000);
+
+  // ─── RED Test #6: createModel throws if API key is missing ───
+
+  it("throws a descriptive error when API key is missing for a cloud provider", async () => {
+    const config: JooneConfig = {
+      ...DEFAULT_CONFIG,
+      provider: "anthropic",
+      model: "claude-sonnet-4-20250514",
+      apiKey: undefined,
+    };
+
+    await expect(createModel(config)).rejects.toThrow(/API key/i);
+  });
+
+  // ─── RED Test #7: createModel throws with install command for missing package ───
+
+  it("throws an error with install instructions for unsupported/missing provider", async () => {
+    const config: JooneConfig = {
+      ...DEFAULT_CONFIG,
+      provider: "unknown-provider",
+      apiKey: "some-key",
+    };
+
+    await expect(createModel(config)).rejects.toThrow(/unsupported provider/i);
+  });
+});