@creativeintelligence/abbie 0.1.4 → 0.1.5

package/src/lib/auto/workspace.ts

@@ -1,282 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-/**
- * Workspace resolution for Luke's Linear setup.
- *
- * Source of truth for team keys: ~/.abbie/projects.json
- */
-let cachedTeamKeys: Set<string> | undefined;
-
-function getTeamKeysFromProjectsJson(): Set<string> {
-  if (cachedTeamKeys) return cachedTeamKeys;
-
-  const keys = new Set<string>();
-  const projectsPath = join(homedir(), ".abbie", "projects.json");
-
-  try {
-    if (!existsSync(projectsPath)) {
-      cachedTeamKeys = keys;
-      return keys;
-    }
-
-    const raw = readFileSync(projectsPath, "utf-8");
-    const parsed = JSON.parse(raw) as {
-      projects?: Record<string, { linearTeam?: string | null }>;
-    };
-
-    for (const project of Object.values(parsed.projects ?? {})) {
-      if (typeof project.linearTeam === "string" && project.linearTeam.trim()) {
-        keys.add(project.linearTeam.toUpperCase());
-      }
-    }
-  } catch {
-    // ignore - treat as no known team keys
-  }
-
-  cachedTeamKeys = keys;
-  return keys;
-}
-
-/**
- * Environment variable names for each workspace's API key.
- */
-const WORKSPACE_API_KEY_ENV: Record<string, string> = {
-  "luke-labs": "LINEAR_API_KEY_LUKE_LABS",
-};
-
-export interface LoopConfig {
-  project?: {
-    name?: string;
-    team?: string;
-    description?: string;
-  };
-  extends?: string;
-}
-
-export interface WorkspaceResolution {
-  team: string | undefined;
-  workspace: string | undefined;
-  apiKey: string | undefined;
-  source: "loop.json" | "env" | "fallback";
-  warning?: string;
-}
-
-/**
- * Read .loop.json from the given directory.
- */
-export function readLoopConfig(cwd: string): LoopConfig | undefined {
-  const configPath = join(cwd, ".loop.json");
-  if (!existsSync(configPath)) {
-    return undefined;
-  }
-
-  try {
-    const raw = readFileSync(configPath, "utf-8");
-    return JSON.parse(raw) as LoopConfig;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Get the workspace for a given team.
- */
-export function getWorkspaceForTeam(team: string): string | undefined {
-  const teamKey = team.toUpperCase();
-  const knownTeams = getTeamKeysFromProjectsJson();
-
-  if (knownTeams.has(teamKey)) {
-    return "luke-labs";
-  }
-
-  return undefined;
-}
-
-/**
- * Get the API key for a given workspace.
- * Checks workspace-specific env vars first, then falls back to LINEAR_API_KEY.
- */
-export function getApiKeyForWorkspace(workspace: string): string | undefined {
-  // First try workspace-specific env var
-  const envName = WORKSPACE_API_KEY_ENV[workspace];
-  if (envName && process.env[envName]) {
-    return process.env[envName];
-  }
-
-  // Fall back to default LINEAR_API_KEY
-  return process.env.LINEAR_API_KEY;
-}
-
-/**
- * Parse LINEAR_API_KEYS env var (comma-separated list of keys).
- */
-export function parseLinearApiKeys(): string[] {
-  const keys = process.env.LINEAR_API_KEYS;
-  if (!keys) return [];
-  return keys
-    .split(",")
-    .map((k) => k.trim())
-    .filter(Boolean);
-}
-
-/**
- * Find an API key from LINEAR_API_KEYS that has access to the expected team.
- * This is async because it needs to query the Linear API.
- */
-export async function findApiKeyForTeam(expectedTeam: string): Promise<string | undefined> {
-  const keys = parseLinearApiKeys();
-  if (keys.length === 0) return undefined;
-
-  for (const key of keys) {
-    const result = await validateApiKeyForTeam(key, expectedTeam);
-    if (result.valid) {
-      return key;
-    }
-  }
-
-  return undefined;
-}
-
-/**
- * Resolve the correct Linear API key for the current directory.
- *
- * Resolution order:
- * 1. Read team from .loop.json
- * 2. Map team to workspace
- * 3. Get API key for workspace from environment
- * 4. Fall back to LINEAR_API_KEY if no workspace-specific key
- */
-export function resolveLinearApiKey(cwd: string): WorkspaceResolution {
-  // Try to read .loop.json
-  const loopConfig = readLoopConfig(cwd);
-  const team = loopConfig?.project?.team;
-
-  if (!team) {
-    // No team configured, use default
-    return {
-      team: undefined,
-      workspace: undefined,
-      apiKey: process.env.LINEAR_API_KEY,
-      source: "fallback",
-      warning: "No team in .loop.json, using default LINEAR_API_KEY",
-    };
-  }
-
-  const workspace = getWorkspaceForTeam(team);
-  if (!workspace) {
-    // Unknown team, use default
-    return {
-      team,
-      workspace: undefined,
-      apiKey: process.env.LINEAR_API_KEY,
-      source: "fallback",
-      warning: `Unknown team "${team}", using default LINEAR_API_KEY`,
-    };
-  }
-
-  // Try workspace-specific API key
-  const envName = WORKSPACE_API_KEY_ENV[workspace];
-  const workspaceApiKey = envName ? process.env[envName] : undefined;
-
-  if (workspaceApiKey) {
-    return {
-      team,
-      workspace,
-      apiKey: workspaceApiKey,
-      source: "env",
-    };
-  }
-
-  // Fall back to default
-  return {
-    team,
-    workspace,
-    apiKey: process.env.LINEAR_API_KEY,
-    source: "fallback",
-    warning: `No ${envName} set for workspace "${workspace}", using default LINEAR_API_KEY which may be wrong workspace`,
-  };
-}
-
-/**
- * Async version of resolveLinearApiKey that validates the key has access
- * to the expected team and falls back to LINEAR_API_KEYS if needed.
- */
-export async function resolveLinearApiKeyAsync(cwd: string): Promise<WorkspaceResolution> {
-  // First get the sync resolution
-  const syncResult = resolveLinearApiKey(cwd);
-
-  // If no team or no API key, nothing to validate
-  if (!syncResult.team || !syncResult.apiKey) {
-    return syncResult;
-  }
-
-  // Validate the resolved key has access to the expected team
-  const validation = await validateApiKeyForTeam(syncResult.apiKey, syncResult.team);
-  if (validation.valid) {
-    return syncResult;
-  }
-
-  // Key doesn't have access - try LINEAR_API_KEYS fallback
-  const fallbackKey = await findApiKeyForTeam(syncResult.team);
-  if (fallbackKey) {
-    return {
-      team: syncResult.team,
-      workspace: syncResult.workspace,
-      apiKey: fallbackKey,
-      source: "env",
-      warning: `Used LINEAR_API_KEYS fallback (${syncResult.source} key lacked access to ${syncResult.team})`,
-    };
-  }
-
-  // No valid key found - return original with warning
-  return {
-    ...syncResult,
-    warning: `No API key found with access to team "${syncResult.team}". Available: ${validation.actualTeams?.join(", ") || "none"}`,
-  };
-}
-
-/**
- * Validate that the API key has access to the expected team.
- * Returns true if validation passes or can't be performed.
- */
-export async function validateApiKeyForTeam(
-  apiKey: string,
-  expectedTeam: string,
-): Promise<{ valid: boolean; actualTeams?: string[]; error?: string }> {
-  try {
-    const response = await fetch("https://api.linear.app/graphql", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: apiKey,
-      },
-      body: JSON.stringify({
-        query: `query { teams { nodes { key name } } }`,
-      }),
-    });
-
-    if (!response.ok) {
-      return { valid: false, error: `API error: ${response.status}` };
-    }
-
-    const data = (await response.json()) as {
-      data?: { teams?: { nodes?: Array<{ key: string; name: string }> } };
-    };
-    const teams = data?.data?.teams?.nodes || [];
-    const teamKeys = teams.map((t) => t.key);
-
-    const hasTeam = teamKeys.some((k) => k.toUpperCase() === expectedTeam.toUpperCase());
-
-    return {
-      valid: hasTeam,
-      actualTeams: teamKeys,
-      error: hasTeam
-        ? undefined
-        : `Team "${expectedTeam}" not found. Available: ${teamKeys.join(", ")}`,
-    };
-  } catch (err) {
-    return { valid: false, error: (err as Error).message };
-  }
-}

package/src/lib/backlog.test.ts

@@ -1,194 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { BacklogManager } from "./backlog";
-
-describe("BacklogManager", () => {
-  let tempDir: string;
-  let manager: BacklogManager;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), "agents-backlog-test-"));
-    manager = new BacklogManager(tempDir);
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-  });
-
-  it("adds a new item", () => {
-    const item = manager.add({
-      type: "issue",
-      ref: "TEST-1",
-      title: "Fix bug",
-      project: "test-project",
-      priority: 1,
-      source: "manual",
-    });
-
-    expect(item.id).toBeDefined();
-    expect(item.status).toBe("pending");
-    expect(item.ref).toBe("TEST-1");
-    expect(item.created_at).toBeDefined();
-
-    // Verify persistence
-    const loaded = manager.get("test-project", item.id);
-    expect(loaded).toMatchObject(item);
-  });
-
-  it("prevents duplicate items by ref", () => {
-    const item1 = manager.add({
-      type: "issue",
-      ref: "TEST-1",
-      title: "Fix bug",
-      project: "test-project",
-      priority: 1,
-      source: "manual",
-    });
-
-    const item2 = manager.add({
-      type: "issue",
-      ref: "TEST-1",
-      title: "Different title",
-      project: "test-project",
-      priority: 2,
-      source: "manual",
-    });
-
-    expect(item2.id).toBe(item1.id);
-    expect(item2.title).toBe("Fix bug"); // Should return existing item
-  });
-
-  it("claims an item", () => {
-    const item = manager.add({
-      type: "issue",
-      ref: "TEST-1",
-      title: "Fix bug",
-      project: "test-project",
-      priority: 1,
-      source: "manual",
-    });
-
-    const result = manager.claim("test-project", item.id, "session-1");
-
-    expect(result.success).toBe(true);
-    expect(result.item?.status).toBe("claimed");
-    expect(result.item?.claimed_by).toBe("session-1");
-    expect(result.item?.claimed_at).toBeDefined();
-  });
-
-  it("fails to claim already claimed item", () => {
-    const item = manager.add({
-      type: "issue",
-      ref: "TEST-1",
-      title: "Fix bug",
-      project: "test-project",
-      priority: 1,
-      source: "manual",
-    });
-
-    manager.claim("test-project", item.id, "session-1");
-    const result = manager.claim("test-project", item.id, "session-2");
-
-    expect(result.success).toBe(false);
-    expect(result.reason).toContain("Already claimed");
-  });
-
-  it("allows reclaiming by same session", () => {
-    const item = manager.add({
-      type: "issue",
-      ref: "TEST-1",
-      title: "Fix bug",
-      project: "test-project",
-      priority: 1,
-      source: "manual",
-    });
-
-    manager.claim("test-project", item.id, "session-1");
-    const result = manager.claim("test-project", item.id, "session-1");
-
-    expect(result.success).toBe(true);
-  });
-
-  it("picks next item by priority", () => {
-    manager.add({
-      type: "issue",
-      ref: "LOW-1",
-      title: "Low priority",
-      project: "test-project",
-      priority: 4,
-      source: "manual",
-    });
-
-    const high = manager.add({
-      type: "issue",
-      ref: "HIGH-1",
-      title: "High priority",
-      project: "test-project",
-      priority: 1,
-      source: "manual",
-    });
-
-    manager.add({
-      type: "issue",
-      ref: "MED-1",
-      title: "Medium priority",
-      project: "test-project",
-      priority: 2,
-      source: "manual",
-    });
-
-    const result = manager.pickNext("test-project", "session-1");
-
-    expect(result.success).toBe(true);
-    expect(result.item?.id).toBe(high.id);
-    expect(result.item?.status).toBe("claimed");
-  });
-
-  it("syncs from Linear with deduplication", () => {
-    const issues = [
-      { id: "1", title: "Task 1", priority: 1, identifier: "LIN-1" },
-      { id: "2", title: "Task 2", priority: 2, identifier: "LIN-2" },
-    ];
-
-    const added = manager.syncFromLinear("test-project", issues);
-    expect(added).toBe(2);
-
-    const issues2 = [
-      { id: "1", title: "Task 1", priority: 1, identifier: "LIN-1" },
-      { id: "3", title: "Task 3", priority: 3, identifier: "LIN-3" },
-    ];
-
-    const added2 = manager.syncFromLinear("test-project", issues2);
-    expect(added2).toBe(1); // Only LIN-3 should be added
-
-    const items = manager.listItems("test-project");
-    expect(items).toHaveLength(3);
-  });
-
-  it("cleans up old completed items", () => {
-    const item = manager.add({
-      type: "issue",
-      ref: "OLD-1",
-      title: "Old item",
-      project: "test-project",
-      priority: 1,
-      source: "manual",
-    });
-
-    manager.complete("test-project", item.id);
-
-    // Mock updated_at to be old
-    const oldDate = new Date();
-    oldDate.setDate(oldDate.getDate() - 31);
-    const path = join(tempDir, "test-project", `${item.id}.json`);
-    const content = JSON.parse(readFileSync(path, "utf-8"));
-    content.updated_at = oldDate.toISOString();
-    writeFileSync(path, JSON.stringify(content));
-
-    const removed = manager.cleanup("test-project", 30);
-    expect(removed).toBe(1);
-    expect(manager.get("test-project", item.id)).toBeUndefined();
-  });
-});