@gokulvenkatareddy/cortex 0.1.7

package/apps/octogent/apps/api/tests/githubRepoSummary.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { readGithubRepoSummary } from "../src/githubRepoSummary";
+
+describe("readGithubRepoSummary", () => {
+  it("returns repository stats, 30-day commit series, and last 50 recent commits", async () => {
+    const recentCommitRecords = Array.from({ length: 52 }, (_, index) => {
+      const offset = index + 1;
+      const day = String(Math.min(28, 28 - index)).padStart(2, "0");
+      return `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa${offset.toString(16)}\u001fshort${offset}\u001fAuthor ${offset}\u001fauthor${offset}@example.com\u001f2026-02-${day}T10:00:00.000Z\u001fbody ${offset}\u001fsubject ${offset}\u001e`;
+    }).join("");
+
+    const shortstatRecords = Array.from({ length: 52 }, (_, index) => {
+      const offset = index + 1;
+      return `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa${offset.toString(16)}\n ${offset + 1} files changed, ${offset * 10} insertions(+), ${offset * 2} deletions(-)\n`;
+    }).join("");
+
+    const runCommand = vi.fn(async (command: string, args: string[]) => {
+      if (command === "gh" && args[0] === "repo" && args[1] === "view") {
+        return {
+          stdout: "hesamsheikh/octogent\n",
+          stderr: "",
+        };
+      }
+
+      if (command === "gh" && args[0] === "api" && args[1] === "graphql") {
+        return {
+          stdout: JSON.stringify({
+            data: {
+              repository: {
+                nameWithOwner: "hesamsheikh/octogent",
+                stargazerCount: 42,
+                issues: { totalCount: 7 },
+                pullRequests: { totalCount: 3 },
+              },
+            },
+          }),
+          stderr: "",
+        };
+      }
+
+      if (command === "git" && args[0] === "log" && args.includes("--pretty=format:%ad")) {
+        return {
+          stdout: "2026-02-27\n2026-02-27\n2026-03-01\n",
+          stderr: "",
+        };
+      }
+
+      if (
+        command === "git" &&
+        args[0] === "log" &&
+        args.includes("--pretty=format:%H%x1f%h%x1f%an%x1f%ae%x1f%aI%x1f%b%x1f%s%x1e")
+      ) {
+        return {
+          stdout: recentCommitRecords,
+          stderr: "",
+        };
+      }
+
+      if (command === "git" && args[0] === "log" && args.includes("--shortstat")) {
+        return {
+          stdout: shortstatRecords,
+          stderr: "",
+        };
+      }
+
+      throw new Error(`Unexpected command: ${command} ${args.join(" ")}`);
+    });
+
+    const snapshot = await readGithubRepoSummary({
+      now: () => new Date("2026-03-03T12:00:00.000Z"),
+      runCommand,
+      cwd: "/workspace",
+      env: {},
+    });
+
+    expect(snapshot.status).toBe("ok");
+    expect(snapshot.repo).toBe("hesamsheikh/octogent");
+    expect(snapshot.stargazerCount).toBe(42);
+    expect(snapshot.openIssueCount).toBe(7);
+    expect(snapshot.openPullRequestCount).toBe(3);
+    expect(snapshot.commitsPerDay).toHaveLength(30);
+    expect(snapshot.commitsPerDay?.find((point) => point.date === "2026-02-27")?.count).toBe(2);
+    expect(snapshot.commitsPerDay?.find((point) => point.date === "2026-03-01")?.count).toBe(1);
+    expect(snapshot.recentCommits).toHaveLength(50);
+    expect(snapshot.recentCommits?.[0]).toEqual({
+      hash: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1",
+      shortHash: "short1",
+      subject: "subject 1",
+      authorName: "Author 1",
+      authorEmail: "author1@example.com",
+      authoredAt: "2026-02-28T10:00:00.000Z",
+      body: "body 1",
+      filesChanged: 2,
+      insertions: 10,
+      deletions: 2,
+    });
+    expect(snapshot.recentCommits?.[49]?.shortHash).toBe("short50");
+  });
+});

package/apps/octogent/apps/api/tests/logging.test.ts

@@ -0,0 +1,33 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { isVerboseLoggingEnabled, logVerbose } from "../src/logging";
+
+describe("logging", () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    vi.restoreAllMocks();
+  });
+
+  it("keeps verbose logs disabled by default", () => {
+    vi.stubEnv("OCTOGENT_VERBOSE_LOGS", undefined);
+
+    expect(isVerboseLoggingEnabled()).toBe(false);
+  });
+
+  it("enables verbose logs when OCTOGENT_VERBOSE_LOGS=1", () => {
+    vi.stubEnv("OCTOGENT_VERBOSE_LOGS", "1");
+
+    expect(isVerboseLoggingEnabled()).toBe(true);
+  });
+
+  it("only writes verbose logs when enabled", () => {
+    const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    logVerbose("hidden");
+    vi.stubEnv("OCTOGENT_VERBOSE_LOGS", "1");
+    logVerbose("shown");
+
+    expect(consoleSpy).toHaveBeenCalledTimes(1);
+    expect(consoleSpy).toHaveBeenCalledWith("shown");
+  });
+});

package/apps/octogent/apps/api/tests/monitorApi.test.ts

@@ -0,0 +1,467 @@
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+const { spawnMock } = vi.hoisted(() => ({
+  spawnMock: vi.fn(),
+}));
+
+vi.mock("node-pty", () => ({
+  spawn: spawnMock,
+}));
+
+import { createApiServer } from "../src/createApiServer";
+import type { GitClient } from "../src/terminalRuntime";
+
+class FakeGitClient implements GitClient {
+  private readonly worktrees = new Map<
+    string,
+    { branchName: string; baseRef: string; cwd: string }
+  >();
+  private readonly branches = new Set<string>();
+
+  assertAvailable(): void {}
+
+  isRepository(): boolean {
+    return true;
+  }
+
+  addWorktree({
+    cwd,
+    path,
+    branchName,
+    baseRef,
+  }: {
+    cwd: string;
+    path: string;
+    branchName: string;
+    baseRef: string;
+  }): void {
+    if (this.worktrees.has(path)) {
+      throw new Error(`Worktree already exists: ${path}`);
+    }
+    mkdirSync(path, { recursive: true });
+    this.branches.add(branchName);
+    this.worktrees.set(path, { cwd, branchName, baseRef });
+  }
+
+  removeWorktree({ path }: { cwd: string; path: string }): void {
+    this.worktrees.delete(path);
+  }
+
+  removeBranch({ branchName }: { cwd: string; branchName: string }): void {
+    this.branches.delete(branchName);
+  }
+
+  readWorktreeStatus(): {
+    branchName: string;
+    upstreamBranchName: string | null;
+    isDirty: boolean;
+    aheadCount: number;
+    behindCount: number;
+    insertedLineCount: number;
+    deletedLineCount: number;
+    hasConflicts: boolean;
+    changedFiles: string[];
+    defaultBaseBranchName: string | null;
+  } {
+    return {
+      branchName: "octogent/tentacle-1",
+      upstreamBranchName: null,
+      isDirty: false,
+      aheadCount: 0,
+      behindCount: 0,
+      insertedLineCount: 0,
+      deletedLineCount: 0,
+      hasConflicts: false,
+      changedFiles: [],
+      defaultBaseBranchName: "main",
+    };
+  }
+
+  commitAll(): void {}
+
+  pushCurrentBranch(): void {}
+
+  syncWithBase(): void {}
+
+  readCurrentBranchPullRequest(): {
+    number: number;
+    url: string;
+    title: string;
+    baseRef: string;
+    headRef: string;
+    state: "OPEN" | "MERGED" | "CLOSED";
+    isDraft: boolean;
+    mergeable: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+    mergeStateStatus: string | null;
+  } | null {
+    return null;
+  }
+
+  createPullRequest(): {
+    number: number;
+    url: string;
+    title: string;
+    baseRef: string;
+    headRef: string;
+    state: "OPEN" | "MERGED" | "CLOSED";
+    isDraft: boolean;
+    mergeable: "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+    mergeStateStatus: string | null;
+  } | null {
+    return null;
+  }
+
+  mergeCurrentBranchPullRequest(): void {}
+}
+
+describe("monitor API routes", () => {
+  let stopServer: (() => Promise<void>) | null = null;
+  const temporaryDirectories: string[] = [];
+
+  afterEach(async () => {
+    if (stopServer) {
+      await stopServer();
+      stopServer = null;
+    }
+
+    for (const directory of temporaryDirectories) {
+      rmSync(directory, { recursive: true, force: true });
+    }
+    temporaryDirectories.length = 0;
+  });
+
+  const startServer = async (options: Partial<Parameters<typeof createApiServer>[0]> = {}) => {
+    const workspaceCwd =
+      options.workspaceCwd ??
+      (() => {
+        const directory = mkdtempSync(join(tmpdir(), "octogent-monitor-api-test-"));
+        temporaryDirectories.push(directory);
+        return directory;
+      })();
+
+    const apiServer = createApiServer({
+      workspaceCwd,
+      gitClient: options.gitClient ?? new FakeGitClient(),
+      ...options,
+    });
+
+    const address = await apiServer.start(0, "127.0.0.1");
+    stopServer = () => apiServer.stop();
+    return `http://${address.host}:${address.port}`;
+  };
+
+  it("returns empty query terms for a fresh workspace config", async () => {
+    const baseUrl = await startServer();
+
+    const response = await fetch(`${baseUrl}/api/monitor/config`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    expect(response.status).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      providerId: "x",
+      queryTerms: [],
+      refreshPolicy: {
+        maxPosts: 30,
+        searchWindowDays: 7,
+      },
+    });
+  });
+
+  it("saves credentials even when query terms have not been configured yet", async () => {
+    const baseUrl = await startServer();
+
+    const patchResponse = await fetch(`${baseUrl}/api/monitor/config`, {
+      method: "PATCH",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        providerId: "x",
+        validateCredentials: false,
+        credentials: {
+          bearerToken: "x-example-secret-token",
+        },
+      }),
+    });
+
+    expect(patchResponse.status).toBe(200);
+    await expect(patchResponse.json()).resolves.toMatchObject({
+      providerId: "x",
+      queryTerms: [],
+      refreshPolicy: {
+        maxPosts: 30,
+        searchWindowDays: 7,
+      },
+      providers: {
+        x: {
+          credentials: {
+            isConfigured: true,
+          },
+        },
+      },
+    });
+
+    const feedResponse = await fetch(`${baseUrl}/api/monitor/feed`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    expect(feedResponse.status).toBe(200);
+    await expect(feedResponse.json()).resolves.toMatchObject({
+      providerId: "x",
+      queryTerms: [],
+      lastError: "At least one monitor query term is required.",
+    });
+  });
+
+  it("saves monitor credentials and returns redacted config", async () => {
+    const baseUrl = await startServer();
+
+    const patchResponse = await fetch(`${baseUrl}/api/monitor/config`, {
+      method: "PATCH",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        providerId: "x",
+        validateCredentials: false,
+        queryTerms: ["AI Engineering", "Codex"],
+        credentials: {
+          bearerToken: "x-example-secret-token",
+          apiKey: "x-api-key-value",
+          apiSecret: "x-api-secret-value",
+        },
+      }),
+    });
+
+    expect(patchResponse.status).toBe(200);
+    const patchPayload = (await patchResponse.json()) as Record<string, unknown>;
+    expect(patchPayload.providerId).toBe("x");
+    expect(patchPayload.queryTerms).toEqual(["AI Engineering", "Codex"]);
+    expect(
+      (patchPayload.refreshPolicy as { maxPosts?: number; searchWindowDays?: number } | undefined)
+        ?.maxPosts,
+    ).toBe(30);
+    expect(
+      (patchPayload.refreshPolicy as { maxPosts?: number; searchWindowDays?: number } | undefined)
+        ?.searchWindowDays,
+    ).toBe(7);
+
+    const providers = patchPayload.providers as Record<string, unknown>;
+    const provider = providers.x as Record<string, unknown>;
+    const credentials = provider.credentials as Record<string, unknown>;
+
+    expect(credentials.isConfigured).toBe(true);
+    expect(typeof credentials.bearerTokenHint).toBe("string");
+    expect((credentials.bearerTokenHint as string).endsWith("oken")).toBe(true);
+    expect(typeof credentials.apiKeyHint).toBe("string");
+    expect((credentials.apiKeyHint as string).endsWith("alue")).toBe(true);
+    expect(Object.hasOwn(credentials, "bearerToken")).toBe(false);
+    expect(Object.hasOwn(credentials, "apiSecret")).toBe(false);
+
+    const getResponse = await fetch(`${baseUrl}/api/monitor/config`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+
+    expect(getResponse.status).toBe(200);
+    await expect(getResponse.json()).resolves.toEqual(patchPayload);
+  });
+
+  it("returns 400 for invalid monitor config patch payload", async () => {
+    const baseUrl = await startServer();
+
+    const response = await fetch(`${baseUrl}/api/monitor/config`, {
+      method: "PATCH",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        queryTerms: "AI Engineering",
+      }),
+    });
+
+    expect(response.status).toBe(400);
+    await expect(response.json()).resolves.toEqual({
+      error: "queryTerms must be an array of strings.",
+    });
+  });
+
+  it("returns 400 for invalid refreshPolicy.maxPosts in monitor config patch payload", async () => {
+    const baseUrl = await startServer();
+
+    const response = await fetch(`${baseUrl}/api/monitor/config`, {
+      method: "PATCH",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        refreshPolicy: {
+          maxPosts: 0,
+        },
+      }),
+    });
+
+    expect(response.status).toBe(400);
+    await expect(response.json()).resolves.toEqual({
+      error: "refreshPolicy.maxPosts must be a positive number.",
+    });
+  });
+
+  it("returns 400 for invalid refreshPolicy.searchWindowDays in monitor config patch payload", async () => {
+    const baseUrl = await startServer();
+
+    const response = await fetch(`${baseUrl}/api/monitor/config`, {
+      method: "PATCH",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        refreshPolicy: {
+          searchWindowDays: 2,
+        },
+      }),
+    });
+
+    expect(response.status).toBe(400);
+    await expect(response.json()).resolves.toEqual({
+      error: "refreshPolicy.searchWindowDays must be one of: 1, 3, 7.",
+    });
+  });
+
+  it("persists configurable maxPosts in monitor refresh policy", async () => {
+    const baseUrl = await startServer();
+
+    const patchResponse = await fetch(`${baseUrl}/api/monitor/config`, {
+      method: "PATCH",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        refreshPolicy: {
+          maxPosts: 12,
+          searchWindowDays: 3,
+        },
+      }),
+    });
+
+    expect(patchResponse.status).toBe(200);
+    await expect(patchResponse.json()).resolves.toMatchObject({
+      refreshPolicy: {
+        maxPosts: 12,
+        searchWindowDays: 3,
+      },
+    });
+
+    const getResponse = await fetch(`${baseUrl}/api/monitor/config`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+    expect(getResponse.status).toBe(200);
+    await expect(getResponse.json()).resolves.toMatchObject({
+      refreshPolicy: {
+        maxPosts: 12,
+        searchWindowDays: 3,
+      },
+    });
+  });
+
+  it("uses non-forced read for feed and forced read for manual refresh", async () => {
+    const readFeedCalls: Array<Record<string, unknown>> = [];
+    const monitorService = {
+      readConfig: async () => ({
+        providerId: "x",
+        queryTerms: ["Codex"],
+        refreshPolicy: {
+          maxCacheAgeMs: 24 * 60 * 60 * 1000,
+          maxPosts: 30,
+          searchWindowDays: 7,
+        },
+        providers: {
+          x: {
+            credentials: {
+              isConfigured: true,
+              bearerTokenHint: "***oken",
+              apiKeyHint: null,
+              hasApiSecret: false,
+              hasAccessToken: false,
+              hasAccessTokenSecret: false,
+              updatedAt: "2026-02-28T12:00:00.000Z",
+            },
+          },
+        },
+      }),
+      patchConfig: async () => {
+        throw new Error("not implemented");
+      },
+      readFeed: async (options?: Record<string, unknown>) => {
+        readFeedCalls.push(options ?? {});
+        return {
+          providerId: "x",
+          queryTerms: ["Codex"],
+          refreshPolicy: {
+            maxCacheAgeMs: 24 * 60 * 60 * 1000,
+            maxPosts: 30,
+            searchWindowDays: 7,
+          },
+          lastFetchedAt: "2026-02-28T12:00:00.000Z",
+          staleAfter: "2026-03-01T12:00:00.000Z",
+          isStale: false,
+          lastError: null,
+          posts: [],
+          usage: null,
+        };
+      },
+    };
+
+    const baseUrl = await startServer({
+      monitorService: monitorService as never,
+    });
+
+    const feedResponse = await fetch(`${baseUrl}/api/monitor/feed`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+    expect(feedResponse.status).toBe(200);
+
+    const manualRefreshResponse = await fetch(`${baseUrl}/api/monitor/refresh`, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+      },
+    });
+    expect(manualRefreshResponse.status).toBe(200);
+
+    expect(readFeedCalls).toEqual([
+      {
+        forceRefresh: false,
+        refreshIfStale: true,
+      },
+      {
+        forceRefresh: true,
+        refreshIfStale: true,
+      },
+    ]);
+  });
+});

package/apps/octogent/apps/api/tests/monitorCore.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "vitest";
+
+import { isMonitorCacheStale, rankAndLimitPostsByLikes } from "../src/monitor/service";
+import type { MonitorPost } from "../src/monitor/types";
+import { buildXRecentSearchQuery } from "../src/monitor/xProvider";
+
+describe("monitor core logic", () => {
+  it("builds X recent-search query with OR terms, lang filter, and no-retweet filter", () => {
+    const query = buildXRecentSearchQuery(["AI Engineering", "Codex"]);
+
+    expect(query).toContain('"AI Engineering"');
+    expect(query).toContain("Codex");
+    expect(query).toContain(" OR ");
+    expect(query).toContain("lang:en");
+    expect(query).toContain("-is:retweet");
+  });
+
+  it("throws when no valid query terms are provided", () => {
+    expect(() => buildXRecentSearchQuery(["", "   "])).toThrow(
+      "At least one X query term is required.",
+    );
+  });
+
+  it("flags cache as stale when older than refresh policy window", () => {
+    const now = new Date("2026-02-28T12:00:00.000Z");
+    const configuredQueryTerms = ["Codex"];
+
+    expect(
+      isMonitorCacheStale({
+        now,
+        maxCacheAgeMs: 24 * 60 * 60 * 1000,
+        lastFetchedAt: null,
+        cachedQueryTerms: configuredQueryTerms,
+        currentQueryTerms: configuredQueryTerms,
+      }),
+    ).toBe(true);
+
+    expect(
+      isMonitorCacheStale({
+        now,
+        maxCacheAgeMs: 24 * 60 * 60 * 1000,
+        lastFetchedAt: "2026-02-27T13:00:00.000Z",
+        cachedQueryTerms: configuredQueryTerms,
+        currentQueryTerms: configuredQueryTerms,
+      }),
+    ).toBe(false);
+
+    expect(
+      isMonitorCacheStale({
+        now,
+        maxCacheAgeMs: 24 * 60 * 60 * 1000,
+        lastFetchedAt: "2026-02-27T11:59:59.000Z",
+        cachedQueryTerms: configuredQueryTerms,
+        currentQueryTerms: configuredQueryTerms,
+      }),
+    ).toBe(true);
+
+    expect(
+      isMonitorCacheStale({
+        now,
+        maxCacheAgeMs: 24 * 60 * 60 * 1000,
+        lastFetchedAt: "2026-02-28T11:00:00.000Z",
+        cachedQueryTerms: ["Codex"],
+        currentQueryTerms: ["Agent Engineering"],
+      }),
+    ).toBe(true);
+  });
+
+  it("dedupes, ranks by like count desc, and limits to top 30", () => {
+    const basePosts: MonitorPost[] = Array.from({ length: 32 }).map((_, index) => ({
+      source: "x",
+      id: `id-${index + 1}`,
+      text: `Post ${index + 1}`,
+      author: `author-${index + 1}`,
+      createdAt: `2026-02-${String((index % 28) + 1).padStart(2, "0")}T10:00:00.000Z`,
+      likeCount: index,
+      permalink: `https://x.com/user/status/${index + 1}`,
+      matchedQueryTerm: "Codex",
+    }));
+    const firstPost = basePosts[0] as MonitorPost;
+    const lastPost = basePosts[31] as MonitorPost;
+
+    const withDuplicate: MonitorPost[] = [
+      ...basePosts,
+      {
+        ...firstPost,
+        text: "duplicate with lower likes should be dropped",
+        likeCount: 0,
+      },
+      {
+        ...lastPost,
+        likeCount: 999,
+      },
+    ];
+
+    const ranked = rankAndLimitPostsByLikes(withDuplicate, 30);
+
+    expect(ranked).toHaveLength(30);
+    expect(ranked[0]?.id).toBe("id-32");
+    expect(ranked[0]?.likeCount).toBe(999);
+    expect(new Set(ranked.map((post) => post.id)).size).toBe(ranked.length);
+    expect(ranked.at(-1)?.likeCount).toBeGreaterThanOrEqual(2);
+  });
+});