letagents 0.12.9 → 0.12.10

package/dist/mcp/__tests__/config-reader.test.js

@@ -1,93 +0,0 @@
-import { findLetagentsConfig, getRoomFromConfig } from "../config-reader";
-import { mkdirSync, writeFileSync, rmSync } from "fs";
-import { join } from "path";
-import { tmpdir } from "os";
-// Helper to create temp directories with config files
-function createTempDir() {
-    const dir = join(tmpdir(), `letagents-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-function cleanup(dir) {
-    try {
-        rmSync(dir, { recursive: true, force: true });
-    }
-    catch {
-        // ignore cleanup errors
-    }
-}
-describe("findLetagentsConfig", () => {
-    let tempDir;
-    afterEach(() => {
-        if (tempDir)
-            cleanup(tempDir);
-    });
-    it("returns config when .letagents.json is in the start directory", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "github.com/EmmyMay/letagents" }));
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toEqual({ room: "github.com/EmmyMay/letagents" });
-    });
-    it("walks up to find config in parent directory", () => {
-        tempDir = createTempDir();
-        const childDir = join(tempDir, "src", "mcp");
-        mkdirSync(childDir, { recursive: true });
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "gitlab.com/team/project" }));
-        const config = findLetagentsConfig(childDir);
-        expect(config).toEqual({ room: "gitlab.com/team/project" });
-    });
-    it("returns null when no config file exists", () => {
-        tempDir = createTempDir();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-    });
-    it("returns null for config with missing room field", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ version: "1.0" }));
-        // Suppress console.error for this test
-        const spy = jest.spyOn(console, "error").mockImplementation();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-        spy.mockRestore();
-    });
-    it("returns null for config with empty room field", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "" }));
-        const spy = jest.spyOn(console, "error").mockImplementation();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-        spy.mockRestore();
-    });
-    it("returns null for invalid JSON", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), "not valid json {{{");
-        const spy = jest.spyOn(console, "error").mockImplementation();
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toBeNull();
-        spy.mockRestore();
-    });
-    it("trims whitespace from room name", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "  github.com/EmmyMay/letagents  " }));
-        const config = findLetagentsConfig(tempDir);
-        expect(config).toEqual({ room: "github.com/EmmyMay/letagents" });
-    });
-});
-describe("getRoomFromConfig", () => {
-    let tempDir;
-    afterEach(() => {
-        if (tempDir)
-            cleanup(tempDir);
-    });
-    it("returns room string when config exists", () => {
-        tempDir = createTempDir();
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "github.com/EmmyMay/letagents" }));
-        const room = getRoomFromConfig(tempDir);
-        expect(room).toBe("github.com/EmmyMay/letagents");
-    });
-    it("returns null when no config exists", () => {
-        tempDir = createTempDir();
-        const room = getRoomFromConfig(tempDir);
-        expect(room).toBeNull();
-    });
-});

package/dist/mcp/__tests__/git-remote.test.js

@@ -1,37 +0,0 @@
-import { normalizeGitRemote } from "../git-remote";
-describe("normalizeGitRemote", () => {
-    // SSH format tests
-    it("normalizes SSH git@github.com format", () => {
-        expect(normalizeGitRemote("git@github.com:EmmyMay/letagents.git")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes SSH without .git suffix", () => {
-        expect(normalizeGitRemote("git@github.com:EmmyMay/letagents")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes SSH with gitlab host", () => {
-        expect(normalizeGitRemote("git@gitlab.com:team/project.git")).toBe("gitlab.com/team/project");
-    });
-    // HTTPS format tests
-    it("normalizes HTTPS with .git suffix", () => {
-        expect(normalizeGitRemote("https://github.com/EmmyMay/letagents.git")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes HTTPS without .git suffix", () => {
-        expect(normalizeGitRemote("https://github.com/EmmyMay/letagents")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("normalizes HTTPS with trailing slash", () => {
-        expect(normalizeGitRemote("https://github.com/EmmyMay/letagents/")).toBe("github.com/EmmyMay/letagents");
-    });
-    // SSH protocol format tests
-    it("normalizes ssh:// protocol format", () => {
-        expect(normalizeGitRemote("ssh://git@gitlab.com/team/project.git")).toBe("gitlab.com/team/project");
-    });
-    // Edge cases
-    it("handles whitespace", () => {
-        expect(normalizeGitRemote("  git@github.com:EmmyMay/letagents.git  ")).toBe("github.com/EmmyMay/letagents");
-    });
-    it("handles nested paths", () => {
-        expect(normalizeGitRemote("https://gitlab.com/org/sub-group/project.git")).toBe("gitlab.com/org/sub-group/project");
-    });
-    it("handles Bitbucket SSH format", () => {
-        expect(normalizeGitRemote("git@bitbucket.org:workspace/repo.git")).toBe("bitbucket.org/workspace/repo");
-    });
-});

package/dist/mcp/__tests__/server-helpers.test.js

@@ -1,121 +0,0 @@
-/**
- * Tests for server helper functions:
- * - resolveGitRoot: resolves the root of a git repo from any subdirectory
- * - findExistingConfig: walks parent dirs to find .letagents.json
- *
- * These helpers underpin the corrected initialize_repo tool behavior.
- * @author Kingdavid Ehindero <kdof64squares@gmail.com>
- */
-import { execSync } from "child_process";
-import { existsSync, mkdirSync, writeFileSync, rmSync } from "fs";
-import { join, resolve } from "path";
-import { tmpdir } from "os";
-// ---------------------------------------------------------------------------
-// Re-implement helpers here (they are not exported from server.ts yet)
-// We test the logic directly until we extract them to a shared module.
-// ---------------------------------------------------------------------------
-function resolveGitRoot(dir) {
-    try {
-        const root = execSync("git rev-parse --show-toplevel", {
-            cwd: dir,
-            stdio: ["pipe", "pipe", "pipe"],
-            encoding: "utf-8",
-        }).trim();
-        return root || null;
-    }
-    catch {
-        return null;
-    }
-}
-function findExistingConfig(startDir) {
-    const { dirname } = require("path");
-    let current = startDir;
-    while (true) {
-        if (existsSync(join(current, ".letagents.json")))
-            return current;
-        const parent = dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return null;
-}
-// ---------------------------------------------------------------------------
-// Helpers for tests
-// ---------------------------------------------------------------------------
-function makeTempGitRepo() {
-    const dir = join(tmpdir(), `letagents-test-${Date.now()}`);
-    mkdirSync(dir, { recursive: true });
-    execSync("git init", { cwd: dir, stdio: "pipe" });
-    execSync("git commit --allow-empty -m init", { cwd: dir, stdio: "pipe" });
-    return dir;
-}
-function cleanup(dir) {
-    try {
-        rmSync(dir, { recursive: true, force: true });
-    }
-    catch { /* ignore */ }
-}
-// ---------------------------------------------------------------------------
-// resolveGitRoot tests
-// ---------------------------------------------------------------------------
-describe("resolveGitRoot", () => {
-    let repoDir;
-    beforeAll(() => { repoDir = makeTempGitRepo(); });
-    afterAll(() => cleanup(repoDir));
-    it("returns the repo root when called from repo root", () => {
-        const result = resolveGitRoot(repoDir);
-        expect(result).toBe(resolve(repoDir));
-    });
-    it("returns the repo root when called from a subdirectory", () => {
-        const subDir = join(repoDir, "src", "deep", "path");
-        mkdirSync(subDir, { recursive: true });
-        const result = resolveGitRoot(subDir);
-        expect(result).toBe(resolve(repoDir));
-    });
-    it("returns null when not inside a git repo", () => {
-        const nonRepoDir = join(tmpdir(), `no-git-${Date.now()}`);
-        mkdirSync(nonRepoDir, { recursive: true });
-        const result = resolveGitRoot(nonRepoDir);
-        cleanup(nonRepoDir);
-        expect(result).toBeNull();
-    });
-    it("returns null for a non-existent directory", () => {
-        const result = resolveGitRoot(join(tmpdir(), "does-not-exist-12345"));
-        expect(result).toBeNull();
-    });
-});
-// ---------------------------------------------------------------------------
-// findExistingConfig tests
-// ---------------------------------------------------------------------------
-describe("findExistingConfig", () => {
-    let tempDir;
-    beforeEach(() => {
-        tempDir = join(tmpdir(), `letagents-cfg-test-${Date.now()}`);
-        mkdirSync(tempDir, { recursive: true });
-    });
-    afterEach(() => cleanup(tempDir));
-    it("returns null when no .letagents.json exists anywhere", () => {
-        const subDir = join(tempDir, "a", "b", "c");
-        mkdirSync(subDir, { recursive: true });
-        expect(findExistingConfig(subDir)).toBeNull();
-    });
-    it("finds config in the start directory", () => {
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "test" }));
-        expect(findExistingConfig(tempDir)).toBe(tempDir);
-    });
-    it("finds config in a parent directory when called from subdirectory", () => {
-        const subDir = join(tempDir, "nested", "path");
-        mkdirSync(subDir, { recursive: true });
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "test" }));
-        expect(findExistingConfig(subDir)).toBe(tempDir);
-    });
-    it("returns the closest config when multiple exist in the tree", () => {
-        const subDir = join(tempDir, "nested");
-        mkdirSync(subDir, { recursive: true });
-        // Config at root and at nested level — should find nested first
-        writeFileSync(join(tempDir, ".letagents.json"), JSON.stringify({ room: "root" }));
-        writeFileSync(join(subDir, ".letagents.json"), JSON.stringify({ room: "nested" }));
-        expect(findExistingConfig(subDir)).toBe(subDir);
-    });
-});

package/dist/shared/agent-reasoning.js

@@ -1,49 +0,0 @@
-const MAX_REASONING_TEXT_LENGTH = 280;
-function normalizeReasoningText(value) {
-    const normalized = String(value ?? "")
-        .replace(/\s+/g, " ")
-        .trim();
-    if (!normalized) {
-        return null;
-    }
-    return normalized.slice(0, MAX_REASONING_TEXT_LENGTH);
-}
-function normalizeReasoningConfidence(value) {
-    if (value === undefined || value === null || value === "") {
-        return null;
-    }
-    const numeric = typeof value === "number" ? value : Number(value);
-    if (!Number.isFinite(numeric)) {
-        return null;
-    }
-    return Math.min(1, Math.max(0, Math.round(numeric * 100) / 100));
-}
-export function normalizeAgentReasoningTrace(value) {
-    if (!value || typeof value !== "object") {
-        return null;
-    }
-    const record = value;
-    const goal = normalizeReasoningText(record.goal);
-    const hypothesis = normalizeReasoningText(record.hypothesis);
-    const checking = normalizeReasoningText(record.checking);
-    const nextAction = normalizeReasoningText(record.next_action);
-    const blocker = normalizeReasoningText(record.blocker);
-    const summary = normalizeReasoningText(record.summary)
-        || goal
-        || nextAction
-        || checking
-        || hypothesis
-        || blocker;
-    if (!summary) {
-        return null;
-    }
-    return {
-        summary,
-        goal,
-        hypothesis,
-        checking,
-        next_action: nextAction,
-        blocker,
-        confidence: normalizeReasoningConfidence(record.confidence),
-    };
-}