@bastani/atomic 0.6.8-0 → 0.7.0-1

package/src/services/config/settings.ts

@@ -1,144 +0,0 @@
-/**
- * User settings persistence
- *
- * Stores user settings (e.g., model selection) across sessions.
- * Settings are resolved in priority order:
- *   1. .atomic/settings.json   (project-local, higher priority)
- *   2. ~/.atomic/settings.json (global, lower priority)
- *
- * The --model CLI flag takes precedence over both (handled at call site).
- */
-
-import { join, dirname } from "node:path";
-import { homedir } from "node:os";
-import { SETTINGS_SCHEMA_URL } from "./settings-schema.ts";
-import { ensureDir } from "../system/copy.ts";
-import { errorMessage } from "../../sdk/errors.ts";
-import { getAgentKeys, type AgentKey, type ProviderOverrides } from "./definitions.ts";
-import type { ScmProvider } from "./atomic-config.ts";
-
-interface AtomicSettings {
-  $schema?: string;
-  version?: number;
-  telemetryEnabled?: boolean;
-  scm?: ScmProvider;
-  providers?: Partial<Record<AgentKey, ProviderOverrides>>;
-}
-
-/** Runtime guard for parsed JSON to ensure it's a plain object. */
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-/** Global settings path: ~/.atomic/settings.json */
-function globalSettingsPath(): string {
-  const home = process.env.ATOMIC_SETTINGS_HOME ?? homedir();
-  return join(home, ".atomic", "settings.json");
-}
-
-async function loadSettingsFile(path: string): Promise<AtomicSettings> {
-  try {
-    const parsed: unknown = await Bun.file(path).json();
-    if (isPlainObject(parsed)) return parsed as AtomicSettings;
-  } catch {
-    // File missing or invalid JSON — fall through to default
-  }
-  return {};
-}
-
-async function writeGlobalSettings(settings: AtomicSettings): Promise<void> {
-  settings.$schema = SETTINGS_SCHEMA_URL;
-  const path = globalSettingsPath();
-  await ensureDir(dirname(path));
-  await Bun.write(path, JSON.stringify(settings, null, 2));
-}
-
-/**
- * Ensure `~/.atomic/settings.json` exists. Called once at CLI startup so
- * users have a valid file to edit (with JSON Schema intellisense wired up
- * via `$schema`) without having to run any explicit init command.
- *
- * Idempotent — no-op if the file already exists. Best-effort: filesystem
- * errors (e.g. read-only home) are swallowed so the CLI never blocks on
- * this side-effect.
- */
-export async function ensureGlobalAtomicSettings(): Promise<void> {
-  try {
-    const path = globalSettingsPath();
-    if (await Bun.file(path).exists()) return;
-    await writeGlobalSettings({ version: 1 });
-  } catch (e) {
-    console.warn(`[settings] failed to bootstrap global settings: ${errorMessage(e)}`);
-  }
-}
-
-/**
- * Set telemetry enabled/disabled in global settings.
- */
-export async function setTelemetryEnabled(enabled: boolean): Promise<void> {
-  try {
-    const settings = await loadSettingsFile(globalSettingsPath());
-    settings.telemetryEnabled = enabled;
-    await writeGlobalSettings(settings);
-  } catch (e) {
-    console.warn(`[settings] failed to set telemetry: ${errorMessage(e)}`);
-  }
-}
-
-/**
- * Set the selected source control provider in global settings.
- *
- * The value is read on every `atomic chat` / `atomic workflow` startup
- * to reconcile the enable/disable state of the GitHub and Azure DevOps
- * MCP servers in `.claude/settings.json` and `.opencode/opencode.json`.
- */
-export async function setScmProvider(scm: ScmProvider): Promise<void> {
-  try {
-    const settings = await loadSettingsFile(globalSettingsPath());
-    settings.scm = scm;
-    await writeGlobalSettings(settings);
-  } catch (e) {
-    console.warn(`[settings] failed to set scm: ${errorMessage(e)}`);
-  }
-}
-
-/**
- * Seed `COLORTERM=truecolor` into each agent's `providers.<agent>.envVars`
- * in `~/.atomic/settings.json` on install / version bump.
- *
- * The runtime default in `lib/terminal-env.ts` already injects
- * `COLORTERM=truecolor` for every spawned agent — this seed surfaces that
- * default in the user-editable settings file so users with terminals that
- * misbehave on truecolor have a discoverable place to override it (set
- * to `""`, `256color`, etc.).
- *
- * Only writes a key when it isn't already present, so user edits — including
- * an explicit empty-string override — are preserved across upgrades.
- */
-export async function seedGlobalProviderEnvVars(): Promise<void> {
-  try {
-    const settings = await loadSettingsFile(globalSettingsPath());
-    const providers: Partial<Record<AgentKey, ProviderOverrides>> =
-      settings.providers ?? {};
-
-    let changed = false;
-    for (const agentKey of getAgentKeys()) {
-      const provider: ProviderOverrides = providers[agentKey] ?? {};
-      const envVars: Record<string, string> = provider.envVars ?? {};
-      if ("COLORTERM" in envVars) continue;
-      envVars.COLORTERM = "truecolor";
-      provider.envVars = envVars;
-      providers[agentKey] = provider;
-      changed = true;
-    }
-
-    if (!changed) return;
-
-    settings.providers = providers;
-    await writeGlobalSettings(settings);
-  } catch (e) {
-    console.warn(
-      `[settings] failed to seed provider envVars: ${errorMessage(e)}`,
-    );
-  }
-}

package/src/services/system/agents.ts

@@ -1,95 +0,0 @@
-/**
- * Merge-copy bundled Atomic agents from the installed package into the
- * provider-native global roots.
- *
- * Mirrors `install_global_agents()` from the production install.sh /
- * install.ps1 bootstrap installers. The bundled agent definitions ship
- * with the npm package (see the `files` array in package.json) at:
- *
- *   <pkg-root>/.claude/agents      → ~/.claude/agents
- *   <pkg-root>/.opencode/agents    → ~/.opencode/agents
- *   <pkg-root>/.github/agents      → ~/.copilot/agents      (rename: github → copilot)
- *   <pkg-root>/.github/lsp.json    → ~/.copilot/lsp-config.json  (rename per atomic-global-config.ts)
- *
- * Copy semantics: files sharing a name with a bundled file are overwritten;
- * unrelated user-added files in those directories are preserved (the
- * `copyDir()` helper iterates source entries, so anything not in the
- * source is left untouched).
- */
-
-import { join, dirname } from "node:path";
-import { homedir } from "node:os";
-import {
-  copyDir,
-  copyFile,
-  ensureDir,
-  pathExists,
-} from "./copy.ts";
-import { createCommonIgnoreFilter } from "../../lib/common-ignore.ts";
-
-/**
- * Locate the package root by walking up from this module. Both in installed
- * (`<pkg>/src/services/system/agents.ts`) and dev checkout layouts the
- * package root is three directories up.
- */
-function packageRoot(): string {
-  return join(import.meta.dir, "..", "..", "..");
-}
-
-/** Honors ATOMIC_SETTINGS_HOME so tests can point at a temp dir. */
-function homeRoot(): string {
-  return process.env.ATOMIC_SETTINGS_HOME ?? homedir();
-}
-
-interface AgentSyncPair {
-  /** Source path relative to package root. */
-  src: string;
-  /** Destination path relative to home root. */
-  dest: string;
-}
-
-const AGENT_DIR_PAIRS: AgentSyncPair[] = [
-  { src: ".claude/agents", dest: ".claude/agents" },
-  { src: ".opencode/agents", dest: ".opencode/agents" },
-  { src: ".github/agents", dest: ".copilot/agents" },
-];
-
-/**
- * Sync bundled agents and the copilot lsp-config to the provider global
- * roots. Throws on hard failures (a single sync failing); missing source
- * directories are warned about and skipped, not thrown.
- */
-export async function installGlobalAgents(): Promise<void> {
-  const pkg = packageRoot();
-  const home = homeRoot();
-
-  const warnings: string[] = [];
-  for (const pair of AGENT_DIR_PAIRS) {
-    const src = join(pkg, pair.src);
-    const dest = join(home, pair.dest);
-
-    if (!(await pathExists(src))) {
-      warnings.push(`bundled agents missing at ${src} — skipping ${dest}`);
-      continue;
-    }
-
-    await copyDir(src, dest, { ignoreFilter: createCommonIgnoreFilter() });
-  }
-
-  // Surface skipped sources via a non-fatal thrown error only if ALL sources
-  // were missing. A partial miss (e.g. one provider folder absent in a dev
-  // checkout) is normal and shouldn't mark the step as failed. The spinner
-  // UI shows the thrown message beneath the failing row.
-  if (warnings.length === AGENT_DIR_PAIRS.length) {
-    throw new Error(warnings.join("\n"));
-  }
-
-  // Copilot's lsp.json is renamed to ~/.copilot/lsp-config.json on disk
-  // (see atomic-global-config.ts for the in-binary rename rationale).
-  const lspSrc = join(pkg, ".github", "lsp.json");
-  const lspDest = join(home, ".copilot", "lsp-config.json");
-  if (await pathExists(lspSrc)) {
-    await ensureDir(dirname(lspDest));
-    await copyFile(lspSrc, lspDest);
-  }
-}

package/src/services/system/auth.test.ts

@@ -1,343 +0,0 @@
-/**
- * Tests for the SDK-level auth probes in `auth.ts`.
- *
- * Both the Copilot SDK and Claude Agent SDK spawn native agent binaries
- * under the hood, which makes the probes unsuitable for unit tests on a
- * CI runner that has neither binary installed. We `mock.module()` each
- * SDK so the probes read from in-test fakes, then assert the wrapper's
- * translation into `AuthCheckResult` shape.
- */
-
-import {
-  describe,
-  test,
-  expect,
-  beforeEach,
-  beforeAll,
-  afterAll,
-  mock,
-} from "bun:test";
-import { chmodSync, mkdtempSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-// ─── Copilot SDK fake ──────────────────────────────────────────────────────
-// `CopilotClient` is a class; the constructor captures latest test state.
-// We swap `start` / `stop` / `getAuthStatus` per-test via mockable fns.
-
-interface CopilotAuthStatus {
-  isAuthenticated: boolean;
-  login?: string;
-  statusMessage?: string;
-}
-
-let copilotStart = mock(async () => {});
-let copilotStop = mock(async () => [] as unknown[]);
-let copilotGetAuthStatus = mock<() => Promise<CopilotAuthStatus>>(async () => ({
-  isAuthenticated: true,
-  login: "octocat",
-}));
-
-// Captures the options passed to `new CopilotClient(...)` on each call.
-let lastCopilotConstructorOptions: unknown = undefined;
-
-class FakeCopilotClient {
-  constructor(options: unknown) {
-    lastCopilotConstructorOptions = options;
-  }
-  async start(): Promise<void> {
-    await copilotStart();
-  }
-  async stop(): Promise<unknown[]> {
-    return copilotStop();
-  }
-  async getAuthStatus(): Promise<CopilotAuthStatus> {
-    return copilotGetAuthStatus();
-  }
-}
-
-// ─── Claude Agent SDK fake ────────────────────────────────────────────────
-// `query()` returns something with `initializationResult()` and `close()`.
-// We ignore the `prompt` stream — the real SDK consumes it lazily, and the
-// probe only calls `initializationResult()` before closing.
-
-interface ClaudeAccount {
-  email?: string;
-  tokenSource?: string;
-  apiKeySource?: string;
-}
-
-let claudeInit = mock<() => Promise<{ account: ClaudeAccount }>>(async () => ({
-  account: { email: "user@example.com", tokenSource: "oauth" },
-}));
-let claudeClose = mock(() => {});
-
-// `mock.module` is process-global in Bun and leaks across every test file
-// loaded in the same run — live ESM bindings in other files rebind to the
-// stub as soon as it registers, and re-registering with the real module in
-// `afterAll` does not restore the original namespace identity. Capture the
-// real SDK modules first, install the mocks only while this file's tests
-// are running, and never mock `claude.ts` (other test files exercise its
-// real exports). All consumers in `auth.ts` use dynamic `await import(...)`,
-// so lazy mock registration is safe here.
-const actualCopilotSdk = await import("@github/copilot-sdk");
-const actualClaudeSdk = await import("@anthropic-ai/claude-agent-sdk");
-
-// Put a fake `claude` binary on PATH so `resolveHeadlessClaudeBin()` (called
-// by `checkClaudeAuth`) succeeds without hitting the real CLI on disk. The
-// mocked SDK `query()` never actually spawns the subprocess — the path is
-// only passed through to the SDK constructor.
-let pathBefore: string | undefined;
-
-beforeAll(() => {
-  const dir = mkdtempSync(join(tmpdir(), "atomic-auth-test-path-"));
-  const bin = join(dir, "claude");
-  writeFileSync(bin, "#!/usr/bin/env sh\nexit 0\n");
-  chmodSync(bin, 0o755);
-  pathBefore = process.env.PATH;
-  process.env.PATH = `${dir}:${process.env.PATH ?? ""}`;
-
-  mock.module("@github/copilot-sdk", () => ({
-    ...actualCopilotSdk,
-    CopilotClient: FakeCopilotClient,
-  }));
-  mock.module("@anthropic-ai/claude-agent-sdk", () => ({
-    ...actualClaudeSdk,
-    query: () => ({
-      initializationResult: () => claudeInit(),
-      close: () => claudeClose(),
-    }),
-  }));
-});
-
-afterAll(() => {
-  if (pathBefore === undefined) delete process.env.PATH;
-  else process.env.PATH = pathBefore;
-  mock.module("@github/copilot-sdk", () => ({ ...actualCopilotSdk }));
-  mock.module("@anthropic-ai/claude-agent-sdk", () => ({ ...actualClaudeSdk }));
-});
-
-const { checkAgentAuth, printAuthError } = await import("./auth.ts");
-
-beforeEach(() => {
-  lastCopilotConstructorOptions = undefined;
-  copilotStart.mockClear();
-  copilotStart.mockImplementation(async () => {});
-  copilotStop.mockClear();
-  copilotStop.mockImplementation(async () => []);
-  copilotGetAuthStatus.mockClear();
-  copilotGetAuthStatus.mockImplementation(async () => ({
-    isAuthenticated: true,
-    login: "octocat",
-  }));
-  claudeInit.mockClear();
-  claudeInit.mockImplementation(async () => ({
-    account: { email: "user@example.com", tokenSource: "oauth" },
-  }));
-  claudeClose.mockClear();
-  claudeClose.mockImplementation(() => {});
-});
-
-describe("checkAgentAuth(copilot)", () => {
-  test("returns loggedIn=true when the SDK reports isAuthenticated", async () => {
-    const result = await checkAgentAuth("copilot");
-    expect(result.loggedIn).toBe(true);
-    expect(result.identity).toBe("octocat");
-    // Hygiene: client must be stopped even on the happy path so we
-    // don't leak a long-running CLI subprocess.
-    expect(copilotStop).toHaveBeenCalledTimes(1);
-  });
-
-  test("returns loggedIn=false when the SDK reports isAuthenticated=false", async () => {
-    copilotGetAuthStatus.mockImplementationOnce(async () => ({
-      isAuthenticated: false,
-      statusMessage: "no credentials on disk",
-    }));
-    const result = await checkAgentAuth("copilot");
-    expect(result.loggedIn).toBe(false);
-    expect(result.detail).toBe("no credentials on disk");
-  });
-
-  test("returns loggedIn=false when the SDK throws on start", async () => {
-    copilotStart.mockImplementationOnce(async () => {
-      throw new Error("CLI not installed");
-    });
-    const result = await checkAgentAuth("copilot");
-    expect(result.loggedIn).toBe(false);
-    expect(result.detail).toContain("CLI not installed");
-  });
-
-  test("swallows errors from stop() on the failure path", async () => {
-    copilotGetAuthStatus.mockImplementationOnce(async () => {
-      throw new Error("auth probe failed");
-    });
-    copilotStop.mockImplementationOnce(async () => {
-      throw new Error("stop crashed");
-    });
-    const result = await checkAgentAuth("copilot");
-    expect(result.loggedIn).toBe(false);
-    expect(result.detail).toContain("auth probe failed");
-    // The stop failure must not shadow the probe result.
-    expect(result.detail).not.toContain("stop crashed");
-  });
-
-  test("constructs CopilotClient with COPILOT_CLI_PATH as cliPath and NODE_NO_WARNINGS=1 in env", async () => {
-    const origCliPath = process.env["COPILOT_CLI_PATH"];
-    process.env["COPILOT_CLI_PATH"] = "/explicit/bin/copilot";
-    try {
-      await checkAgentAuth("copilot");
-      const opts = lastCopilotConstructorOptions as {
-        cliPath?: string;
-        env?: Record<string, string | undefined>;
-      };
-      expect(opts).toBeDefined();
-      expect(opts.cliPath).toBe("/explicit/bin/copilot");
-      expect(opts.env?.["NODE_NO_WARNINGS"]).toBe("1");
-    } finally {
-      if (origCliPath === undefined) delete process.env["COPILOT_CLI_PATH"];
-      else process.env["COPILOT_CLI_PATH"] = origCliPath;
-    }
-  });
-
-  test("constructs CopilotClient via centralized launch options — env.NODE_NO_WARNINGS=1 present even when COPILOT_CLI_PATH is unset", async () => {
-    // When COPILOT_CLI_PATH is absent the auth probe delegates entirely to
-    // copilotSdkLaunchOptions(), which always injects NODE_NO_WARNINGS=1
-    // via copilotSubprocessEnv(). No cliPath should appear in the options
-    // because resolveCopilotCliPath() returns undefined when the env var is
-    // not set and no standalone binary is found on PATH.
-    const origCliPath = process.env["COPILOT_CLI_PATH"];
-    delete process.env["COPILOT_CLI_PATH"];
-    try {
-      await checkAgentAuth("copilot");
-      const opts = lastCopilotConstructorOptions as {
-        cliPath?: string;
-        env?: Record<string, string | undefined>;
-      };
-      expect(opts).toBeDefined();
-      // Centralized env must always include NODE_NO_WARNINGS regardless of cliPath.
-      expect(opts.env?.["NODE_NO_WARNINGS"]).toBe("1");
-      // cliPath must not be injected from a stale or undefined resolution.
-      // (It may be defined if a copilot binary happens to be on PATH in the
-      // test environment, but it must never be "/explicit/bin/copilot" which
-      // is only set by the sibling test above.)
-      expect(opts.cliPath).not.toBe("/explicit/bin/copilot");
-    } finally {
-      if (origCliPath === undefined) delete process.env["COPILOT_CLI_PATH"];
-      else process.env["COPILOT_CLI_PATH"] = origCliPath;
-    }
-  });
-});
-
-describe("checkAgentAuth(claude)", () => {
-  test("returns loggedIn=true when initializationResult has account email", async () => {
-    const result = await checkAgentAuth("claude");
-    expect(result.loggedIn).toBe(true);
-    expect(result.identity).toBe("user@example.com");
-    expect(claudeClose).toHaveBeenCalledTimes(1);
-  });
-
-  test("returns loggedIn=true when only tokenSource is populated", async () => {
-    claudeInit.mockImplementationOnce(async () => ({
-      account: { tokenSource: "oauth" },
-    }));
-    const result = await checkAgentAuth("claude");
-    expect(result.loggedIn).toBe(true);
-  });
-
-  test("returns loggedIn=true when only apiKeySource is populated", async () => {
-    claudeInit.mockImplementationOnce(async () => ({
-      account: { apiKeySource: "env" },
-    }));
-    const result = await checkAgentAuth("claude");
-    expect(result.loggedIn).toBe(true);
-  });
-
-  test("returns loggedIn=false when account is empty", async () => {
-    claudeInit.mockImplementationOnce(async () => ({ account: {} }));
-    const result = await checkAgentAuth("claude");
-    expect(result.loggedIn).toBe(false);
-  });
-
-  test("returns loggedIn=false when initializationResult throws", async () => {
-    claudeInit.mockImplementationOnce(async () => {
-      throw new Error("subprocess init failed — check authentication");
-    });
-    const result = await checkAgentAuth("claude");
-    expect(result.loggedIn).toBe(false);
-    expect(result.detail).toContain("subprocess init failed");
-  });
-});
-
-describe("checkAgentAuth(opencode)", () => {
-  test("is a no-op — returns loggedIn=true without probing the SDK", async () => {
-    // OpenCode handles auth interactively on first use; there's no
-    // equivalent RPC probe, so the wrapper short-circuits.
-    const result = await checkAgentAuth("opencode");
-    expect(result.loggedIn).toBe(true);
-    // Confirm neither SDK fake was touched.
-    expect(copilotStart).not.toHaveBeenCalled();
-    expect(claudeInit).not.toHaveBeenCalled();
-  });
-});
-
-describe("printAuthError", () => {
-  function captureStderr(): {
-    output: () => string;
-    restore: () => void;
-  } {
-    const chunks: string[] = [];
-    const orig = process.stderr.write;
-    process.stderr.write = ((c: string | Uint8Array) => {
-      chunks.push(typeof c === "string" ? c : new TextDecoder().decode(c));
-      return true;
-    }) as typeof process.stderr.write;
-    const origErr = console.error;
-    console.error = (...args: unknown[]) => {
-      chunks.push(args.map((a) => String(a)).join(" ") + "\n");
-    };
-    return {
-      output: () => chunks.join(""),
-      restore: () => {
-        process.stderr.write = orig;
-        console.error = origErr;
-      },
-    };
-  }
-
-  test("prints the Claude login hint with optional detail line", () => {
-    const cap = captureStderr();
-    try {
-      printAuthError("claude", { loggedIn: false, detail: "token expired" });
-      const out = cap.output();
-      expect(out).toContain("Not logged in to Claude Code");
-      expect(out).toContain("token expired");
-      expect(out).toContain("/login");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("omits the detail line when no detail is given", () => {
-    const cap = captureStderr();
-    try {
-      printAuthError("copilot", { loggedIn: false });
-      const out = cap.output();
-      expect(out).toContain("Not logged in to GitHub Copilot CLI");
-      expect(out).toContain("`/login`");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  test("prints the OpenCode login hint", () => {
-    const cap = captureStderr();
-    try {
-      printAuthError("opencode", { loggedIn: false });
-      const out = cap.output();
-      expect(out).toContain("Not logged in to OpenCode");
-      expect(out).toContain("opencode auth login");
-    } finally {
-      cap.restore();
-    }
-  });
-});