pretticlaw 0.1.0

package/test/context.test.ts

@@ -0,0 +1,27 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { describe, expect, test } from "vitest";
+import { ContextBuilder } from "../src/agent/context.js";
+
+describe("context runtime separation", () => {
+  test("runtime context is separate untrusted user message", () => {
+    const workspace = fs.mkdtempSync(path.join(os.tmpdir(), "pretticlaw-ctx-"));
+    fs.writeFileSync(path.join(workspace, "AGENTS.md"), "agent", "utf8");
+    const ctx = new ContextBuilder(workspace);
+    const messages = ctx.buildMessages({ history: [], currentMessage: "Return exactly: OK", channel: "cli", chatId: "direct" });
+
+    expect(messages[0].role).toBe("system");
+    expect(String(messages[0].content)).not.toContain("## Current Session");
+
+    const runtimeContent = String(messages[messages.length - 2].content);
+    expect(messages[messages.length - 2].role).toBe("user");
+    expect(runtimeContent).toContain(ContextBuilder.RUNTIME_CONTEXT_TAG);
+    expect(runtimeContent).toContain("Current Time:");
+    expect(runtimeContent).toContain("Channel: cli");
+    expect(runtimeContent).toContain("Chat ID: direct");
+
+    expect(messages[messages.length - 1].role).toBe("user");
+    expect(messages[messages.length - 1].content).toBe("Return exactly: OK");
+  });
+});

package/test/cron-service.test.ts

@@ -0,0 +1,31 @@
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { describe, expect, test } from "vitest";
+import { CronService } from "../src/cron/service.js";
+
+describe("cron timezone", () => {
+  test("rejects unknown timezone", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pretticlaw-cron-"));
+    const service = new CronService(path.join(dir, "jobs.json"));
+    expect(() => {
+      service.addJob({
+        name: "bad",
+        schedule: { kind: "cron", expr: "0 9 * * *", tz: "America/Vancovuer" },
+        message: "hello",
+      });
+    }).toThrow("unknown timezone 'America/Vancovuer'");
+  });
+
+  test("accepts valid timezone", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "pretticlaw-cron-"));
+    const service = new CronService(path.join(dir, "jobs.json"));
+    const job = service.addJob({
+      name: "good",
+      schedule: { kind: "cron", expr: "0 9 * * *", tz: "America/Vancouver" },
+      message: "hello",
+    });
+    expect((job.schedule as any).tz).toBe("America/Vancouver");
+    expect(job.state.nextRunAtMs).not.toBeNull();
+  });
+});

package/test/message-tool.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, test } from "vitest";
+import { MessageTool } from "../src/agent/tools/message.js";
+
+describe("message tool", () => {
+  test("returns error when no target context", async () => {
+    const tool = new MessageTool();
+    const result = await tool.execute({ content: "test" });
+    expect(result).toBe("Error: No target channel/chat specified");
+  });
+});

package/test/providers.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "vitest";
+import { DEFAULT_CONFIG, getProviderName } from "../src/config/schema.js";
+import { findByModel } from "../src/providers/registry.js";
+import { LiteLLMProvider } from "../src/providers/litellm-provider.js";
+import { stripModelPrefix } from "../src/providers/registry.js";
+
+describe("provider matching", () => {
+  test("matches github copilot with hyphen prefix", () => {
+    const config = structuredClone(DEFAULT_CONFIG);
+    config.agents.defaults.model = "github-copilot/gpt-5.3-codex";
+    config.providers.github_copilot.apiKey = "oauth";
+    expect(getProviderName(config)).toBe("github_copilot");
+  });
+
+  test("matches openai codex with hyphen prefix", () => {
+    const config = structuredClone(DEFAULT_CONFIG);
+    config.agents.defaults.model = "openai-codex/gpt-5.1-codex";
+    config.providers.openai_codex.apiKey = "oauth";
+    expect(getProviderName(config)).toBe("openai_codex");
+  });
+
+  test("find by model prefers explicit prefix", () => {
+    const spec = findByModel("github-copilot/gpt-5.3-codex");
+    expect(spec?.name).toBe("github_copilot");
+  });
+
+  test("canonicalizes github copilot hyphen prefix", () => {
+    const provider = new LiteLLMProvider(null, null, "github-copilot/gpt-5.3-codex", null);
+    expect(provider.resolveModel("github-copilot/gpt-5.3-codex")).toBe("github_copilot/gpt-5.3-codex");
+  });
+
+  test("strips groq/ prefix for groq models", () => {
+    const provider = new LiteLLMProvider("key", "https://api.groq.com/openai/v1", "llama-3.3-70b-versatile", "groq");
+    expect(provider.resolveModel("groq/llama-3.3-70b-versatile")).toBe("llama-3.3-70b-versatile");
+    expect(provider.resolveModel("openai/gpt-oss-120b")).toBe("openai/gpt-oss-120b");
+    expect(provider.resolveModel("groq/compound")).toBe("groq/compound");
+  });
+
+  test("openai codex strip prefix supports hyphen and underscore", () => {
+    expect(stripModelPrefix("openai-codex/gpt-5.1-codex")).toBe("gpt-5.1-codex");
+    expect(stripModelPrefix("openai_codex/gpt-5.1-codex")).toBe("gpt-5.1-codex");
+  });
+});

package/test/tool-validation.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "vitest";
+import { Tool } from "../src/agent/tools/base.js";
+import { ToolRegistry } from "../src/agent/tools/registry.js";
+
+class SampleTool extends Tool {
+  readonly name = "sample";
+  readonly description = "sample tool";
+  readonly parameters = {
+    type: "object",
+    properties: {
+      query: { type: "string", minLength: 2 },
+      count: { type: "integer", minimum: 1, maximum: 10 },
+      mode: { type: "string", enum: ["fast", "full"] },
+      meta: {
+        type: "object",
+        properties: {
+          tag: { type: "string" },
+          flags: { type: "array", items: { type: "string" } },
+        },
+        required: ["tag"],
+      },
+    },
+    required: ["query", "count"],
+  };
+  async execute(): Promise<string> { return "ok"; }
+}
+
+describe("tool validation", () => {
+  test("missing required", () => {
+    const tool = new SampleTool();
+    const errors = tool.validateParams({ query: "hi" });
+    expect(errors.join("; ")).toContain("missing required count");
+  });
+
+  test("type and range", () => {
+    const tool = new SampleTool();
+    expect(tool.validateParams({ query: "hi", count: 0 }).some((e) => e.includes("count must be >= 1"))).toBe(true);
+    expect(tool.validateParams({ query: "hi", count: "2" as any }).some((e) => e.includes("count should be integer"))).toBe(true);
+  });
+
+  test("enum and min length", () => {
+    const tool = new SampleTool();
+    const errors = tool.validateParams({ query: "h", count: 2, mode: "slow" });
+    expect(errors.some((e) => e.includes("query must be at least 2 chars"))).toBe(true);
+    expect(errors.some((e) => e.includes("mode must be one of"))).toBe(true);
+  });
+
+  test("nested object and array", () => {
+    const tool = new SampleTool();
+    const errors = tool.validateParams({ query: "hi", count: 2, meta: { flags: [1, "ok"] } });
+    expect(errors.some((e) => e.includes("missing required meta.tag"))).toBe(true);
+    expect(errors.some((e) => e.includes("meta.flags[0] should be string"))).toBe(true);
+  });
+
+  test("registry returns validation error", async () => {
+    const reg = new ToolRegistry();
+    reg.register(new SampleTool());
+    const result = await reg.execute("sample", { query: "hi" });
+    expect(result).toContain("Invalid parameters");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.d.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["test/**/*.test.ts"],
+  },
+});