openalmanac 0.3.6 → 0.4.1

package/dist/setup/clients.js

@@ -0,0 +1,291 @@
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { ALMANAC_MCP_ENTRY, CLAUDE_CODE_MCP, CLAUDE_DIR, CLAUDE_JSON, CODEX_CONFIG, CURSOR_MCP_JSON, OPENCODE_DIR, OPENCODE_JSON, OPENCODE_JSONC, WINDSURF_MCP_JSON, codexSnippet, configureCodexToml, configureJsonMcpFile, configureOpenCodeFile, getClaudeDesktopConfigPath, getOpenCodeConfigPath, hasCommand, isClaudeDesktopInstalled, jsonSnippet, } from "./config-files.js";
+export const SUPPORTED_CLIENT_IDS = [
+    "claude-code",
+    "claude-desktop",
+    "codex",
+    "cursor",
+    "opencode",
+    "windsurf",
+];
+export const SUPPORTED_CLIENTS = {
+    "claude-code": {
+        id: "claude-code",
+        name: "Claude Code",
+        selectionLabel: "Claude Code",
+        detect: () => hasCommand("claude") || existsSync(CLAUDE_JSON) || existsSync(CLAUDE_DIR),
+        configure: (mode) => {
+            const snippets = [
+                {
+                    path: CLAUDE_JSON,
+                    content: jsonSnippet({
+                        mcpServers: {
+                            almanac: { ...ALMANAC_MCP_ENTRY },
+                        },
+                    }),
+                },
+                {
+                    path: CLAUDE_CODE_MCP,
+                    content: jsonSnippet({
+                        mcpServers: {
+                            almanac: { ...ALMANAC_MCP_ENTRY },
+                        },
+                    }),
+                },
+            ];
+            const changedPrimary = configureJsonMcpFile(CLAUDE_JSON, mode);
+            const changedSecondary = configureJsonMcpFile(CLAUDE_CODE_MCP, mode);
+            return { changed: changedPrimary || changedSecondary, snippets };
+        },
+        supportsPermissions: true,
+    },
+    "claude-desktop": {
+        id: "claude-desktop",
+        name: "Claude Desktop",
+        selectionLabel: "Claude Desktop",
+        detect: () => {
+            const path = getClaudeDesktopConfigPath();
+            return Boolean(path && (existsSync(path) || isClaudeDesktopInstalled()));
+        },
+        configure: (mode) => {
+            const path = getClaudeDesktopConfigPath();
+            if (!path)
+                return { changed: false, snippets: [] };
+            return {
+                changed: configureJsonMcpFile(path, mode),
+                snippets: [
+                    {
+                        path,
+                        content: jsonSnippet({
+                            mcpServers: {
+                                almanac: { ...ALMANAC_MCP_ENTRY },
+                            },
+                        }),
+                    },
+                ],
+            };
+        },
+    },
+    codex: {
+        id: "codex",
+        name: "Codex",
+        selectionLabel: "Codex",
+        detect: () => hasCommand("codex") || existsSync(CODEX_CONFIG) || existsSync(join(homedir(), ".codex")),
+        configure: (mode) => ({
+            changed: configureCodexToml(CODEX_CONFIG, mode),
+            snippets: [
+                {
+                    path: CODEX_CONFIG,
+                    content: codexSnippet(),
+                },
+            ],
+        }),
+    },
+    cursor: {
+        id: "cursor",
+        name: "Cursor",
+        selectionLabel: "Cursor",
+        detect: () => hasCommand("cursor-agent") ||
+            existsSync(CURSOR_MCP_JSON) ||
+            existsSync(join(homedir(), ".cursor")),
+        configure: (mode) => ({
+            changed: configureJsonMcpFile(CURSOR_MCP_JSON, mode),
+            snippets: [
+                {
+                    path: CURSOR_MCP_JSON,
+                    content: jsonSnippet({
+                        mcpServers: {
+                            almanac: { ...ALMANAC_MCP_ENTRY },
+                        },
+                    }),
+                },
+            ],
+        }),
+    },
+    opencode: {
+        id: "opencode",
+        name: "OpenCode",
+        selectionLabel: "OpenCode",
+        detect: () => hasCommand("opencode") ||
+            existsSync(OPENCODE_JSON) ||
+            existsSync(OPENCODE_JSONC) ||
+            existsSync(OPENCODE_DIR),
+        configure: (mode) => {
+            const path = getOpenCodeConfigPath();
+            return {
+                changed: configureOpenCodeFile(path, mode),
+                snippets: [
+                    {
+                        path,
+                        content: jsonSnippet({
+                            "$schema": "https://opencode.ai/config.json",
+                            mcp: {
+                                almanac: {
+                                    type: "local",
+                                    command: [ALMANAC_MCP_ENTRY.command, ...ALMANAC_MCP_ENTRY.args],
+                                    enabled: true,
+                                },
+                            },
+                        }),
+                    },
+                ],
+            };
+        },
+    },
+    windsurf: {
+        id: "windsurf",
+        name: "Windsurf",
+        selectionLabel: "Windsurf",
+        detect: () => hasCommand("windsurf") ||
+            existsSync(WINDSURF_MCP_JSON) ||
+            existsSync(join(homedir(), ".codeium")),
+        configure: (mode) => ({
+            changed: configureJsonMcpFile(WINDSURF_MCP_JSON, mode),
+            snippets: [
+                {
+                    path: WINDSURF_MCP_JSON,
+                    content: jsonSnippet({
+                        mcpServers: {
+                            almanac: { ...ALMANAC_MCP_ENTRY },
+                        },
+                    }),
+                },
+            ],
+        }),
+    },
+};
+export function parseSetupArgs(argv) {
+    const options = {
+        all: false,
+        clients: [],
+        dryRun: false,
+        print: false,
+        yes: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--all") {
+            options.all = true;
+            continue;
+        }
+        if (arg === "--print") {
+            options.print = true;
+            continue;
+        }
+        if (arg === "--dry-run") {
+            options.dryRun = true;
+            continue;
+        }
+        if (arg === "--yes" || arg === "-y") {
+            options.yes = true;
+            continue;
+        }
+        if (arg === "--client") {
+            const value = argv[i + 1];
+            if (!value) {
+                throw new Error("Missing value for --client");
+            }
+            i++;
+            options.clients.push(...parseClientList(value));
+            continue;
+        }
+        if (arg.startsWith("--client=")) {
+            options.clients.push(...parseClientList(arg.slice("--client=".length)));
+            continue;
+        }
+        throw new Error(`Unknown setup flag: ${arg}`);
+    }
+    if (options.all && options.clients.length > 0) {
+        throw new Error("Use either --all or --client, not both");
+    }
+    options.clients = Array.from(new Set(options.clients));
+    return options;
+}
+export function parseClientList(value) {
+    return value
+        .split(",")
+        .map((part) => part.trim().toLowerCase())
+        .filter(Boolean)
+        .map((part) => normalizeClientId(part));
+}
+export function normalizeClientId(value) {
+    const aliases = {
+        claude: "claude-code",
+        "claude-code": "claude-code",
+        "claude-desktop": "claude-desktop",
+        desktop: "claude-desktop",
+        codex: "codex",
+        cursor: "cursor",
+        opencode: "opencode",
+        windsurf: "windsurf",
+    };
+    const normalized = aliases[value];
+    if (!normalized) {
+        throw new Error(`Unsupported client "${value}". Supported clients: ${SUPPORTED_CLIENT_IDS.join(", ")}`);
+    }
+    return normalized;
+}
+export function detectClients() {
+    return SUPPORTED_CLIENT_IDS.map((id) => SUPPORTED_CLIENTS[id]).filter((client) => client.detect());
+}
+export function resolveClients(options) {
+    if (options.clients.length > 0) {
+        return options.clients.map((id) => SUPPORTED_CLIENTS[id]);
+    }
+    const detected = detectClients();
+    if (options.all)
+        return detected;
+    return detected;
+}
+export function applyClientSetup(clients, mode) {
+    const configured = [];
+    const alreadyConfigured = [];
+    for (const client of clients) {
+        const result = client.configure(mode);
+        if (result.changed) {
+            configured.push(client.name);
+        }
+        else {
+            alreadyConfigured.push(client.name);
+        }
+    }
+    return { configured, alreadyConfigured };
+}
+export function printSetupPlan(clients, options) {
+    const heading = options.dryRun ? "Dry run" : "OpenAlmanac MCP setup";
+    process.stdout.write(`${heading}\n\n`);
+    if (clients.length === 0) {
+        process.stdout.write("No supported clients detected. Use --client <name> to force a target or --print to inspect supported snippets.\n");
+        if (options.print) {
+            process.stdout.write("\nSupported clients:\n");
+            for (const id of SUPPORTED_CLIENT_IDS) {
+                process.stdout.write(`- ${SUPPORTED_CLIENTS[id].name}\n`);
+            }
+        }
+        return;
+    }
+    const mode = options.print ? "print" : "dry-run";
+    for (const client of clients) {
+        const result = client.configure(mode);
+        const status = result.changed
+            ? options.print
+                ? "snippet"
+                : "would configure"
+            : "already configured";
+        process.stdout.write(`- ${client.name}: ${status}\n`);
+        if (options.print) {
+            for (const snippet of result.snippets) {
+                process.stdout.write(`  Path: ${snippet.path}\n`);
+                process.stdout.write(`${indentBlock(snippet.content, "    ")}\n`);
+            }
+        }
+    }
+}
+function indentBlock(content, prefix) {
+    return content
+        .split("\n")
+        .map((line) => `${prefix}${line}`)
+        .join("\n");
+}

package/dist/setup/config-files.d.ts

@@ -0,0 +1,43 @@
+import type { ConfigureMode } from "./types.js";
+export declare const CLAUDE_DIR: string;
+export declare const CLAUDE_JSON: string;
+export declare const CLAUDE_CODE_MCP: string;
+export declare const SETTINGS_JSON: string;
+export declare const CODEX_CONFIG: string;
+export declare const CURSOR_MCP_JSON: string;
+export declare const OPENCODE_DIR: string;
+export declare const OPENCODE_JSON: string;
+export declare const OPENCODE_JSONC: string;
+export declare const WINDSURF_MCP_JSON: string;
+export declare function ensureDir(dir: string): void;
+export declare function readJson(path: string): Record<string, unknown>;
+export declare function writeJson(path: string, data: Record<string, unknown>): void;
+export declare const ALMANAC_MCP_ENTRY: {
+    readonly command: "npx";
+    readonly args: readonly ["-y", "openalmanac@latest"];
+};
+export declare function hasCommand(command: string): boolean;
+export declare function getClaudeDesktopConfigPath(): string | null;
+export declare function isClaudeDesktopInstalled(): boolean;
+export declare function jsonSnippet(data: Record<string, unknown>): string;
+export declare function getOpenCodeConfigPath(): string;
+export declare function codexSnippet(): string;
+export declare function isAlmanacCurrent(server: {
+    command?: string;
+    args?: string[];
+} | undefined): boolean;
+export declare function isOpenCodeAlmanacCurrent(entry: {
+    type?: string;
+    command?: string[];
+    enabled?: boolean;
+} | undefined): boolean;
+export declare function configureJsonMcpFile(path: string, mode: ConfigureMode): boolean;
+export declare function configureCodexToml(path: string, mode: ConfigureMode): boolean;
+export declare function configureOpenCodeFile(path: string, mode: ConfigureMode): boolean;
+export declare function readToml(path: string): string;
+export declare function readJsonWithComments(path: string): Record<string, unknown>;
+export declare function stripJsonComments(input: string): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function upsertCodexServer(content: string): string;
+export declare function tomlString(value: string): string;
+export declare function tomlArray(values: readonly string[]): string;

package/dist/setup/config-files.js

@@ -0,0 +1,257 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { spawnSync } from "child_process";
+export const CLAUDE_DIR = join(homedir(), ".claude");
+export const CLAUDE_JSON = join(homedir(), ".claude.json"); // Claude Code user-scoped MCP config
+export const CLAUDE_CODE_MCP = join(CLAUDE_DIR, "mcp.json"); // Claude Code local MCP config
+export const SETTINGS_JSON = join(CLAUDE_DIR, "settings.json");
+export const CODEX_CONFIG = join(homedir(), ".codex", "config.toml");
+export const CURSOR_MCP_JSON = join(homedir(), ".cursor", "mcp.json");
+export const OPENCODE_DIR = join(homedir(), ".config", "opencode");
+export const OPENCODE_JSON = join(OPENCODE_DIR, "opencode.json");
+export const OPENCODE_JSONC = join(OPENCODE_DIR, "opencode.jsonc");
+export const WINDSURF_MCP_JSON = join(homedir(), ".codeium", "mcp_config.json");
+export function ensureDir(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+}
+export function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeJson(path, data) {
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n");
+}
+/* ── Step 1 — MCP server ───────────────────────────────────────── */
+export const ALMANAC_MCP_ENTRY = { command: "npx", args: ["-y", "openalmanac@latest"] };
+export function hasCommand(command) {
+    const checker = process.platform === "win32" ? "where" : "which";
+    const result = spawnSync(checker, [command], { stdio: "ignore" });
+    return result.status === 0;
+}
+export function getClaudeDesktopConfigPath() {
+    if (process.platform === "darwin") {
+        return join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "linux") {
+        return join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+    }
+    if (process.platform === "win32") {
+        const appData = process.env.APPDATA;
+        if (!appData)
+            return null;
+        return join(appData, "Claude", "claude_desktop_config.json");
+    }
+    return null;
+}
+export function isClaudeDesktopInstalled() {
+    if (process.platform === "darwin") {
+        return (existsSync("/Applications/Claude.app") ||
+            existsSync(join(homedir(), "Applications", "Claude.app")));
+    }
+    if (process.platform === "linux") {
+        return (existsSync("/usr/share/applications/claude.desktop") ||
+            existsSync(join(homedir(), ".local", "share", "applications", "claude.desktop")) ||
+            existsSync("/opt/Claude/claude"));
+    }
+    if (process.platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA;
+        const programFiles = process.env.ProgramFiles;
+        return Boolean((localAppData &&
+            existsSync(join(localAppData, "Programs", "Claude", "Claude.exe"))) ||
+            (programFiles && existsSync(join(programFiles, "Claude", "Claude.exe"))));
+    }
+    return false;
+}
+export function jsonSnippet(data) {
+    return JSON.stringify(data, null, 2);
+}
+export function getOpenCodeConfigPath() {
+    if (existsSync(OPENCODE_JSON))
+        return OPENCODE_JSON;
+    if (existsSync(OPENCODE_JSONC))
+        return OPENCODE_JSONC;
+    return OPENCODE_JSON;
+}
+export function codexSnippet() {
+    return [
+        "[mcp_servers.almanac]",
+        `command = ${tomlString(ALMANAC_MCP_ENTRY.command)}`,
+        `args = ${tomlArray(ALMANAC_MCP_ENTRY.args)}`,
+    ].join("\n");
+}
+export function isAlmanacCurrent(server) {
+    return (server?.command === "npx" &&
+        JSON.stringify(server.args) === JSON.stringify(ALMANAC_MCP_ENTRY.args));
+}
+export function isOpenCodeAlmanacCurrent(entry) {
+    return (entry?.type === "local" &&
+        entry?.enabled === true &&
+        JSON.stringify(entry.command) ===
+            JSON.stringify([ALMANAC_MCP_ENTRY.command, ...ALMANAC_MCP_ENTRY.args]));
+}
+export function configureJsonMcpFile(path, mode) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const json = readJson(path);
+    if (!json.mcpServers)
+        json.mcpServers = {};
+    if (isAlmanacCurrent(json.mcpServers.almanac)) {
+        return false;
+    }
+    if (mode === "apply") {
+        ensureDir(dirname(path));
+        json.mcpServers.almanac = { ...ALMANAC_MCP_ENTRY };
+        writeJson(path, json);
+    }
+    return true;
+}
+export function configureCodexToml(path, mode) {
+    const current = readToml(path);
+    const next = upsertCodexServer(current);
+    if (current.trim() === next.trim()) {
+        return false;
+    }
+    if (mode === "apply") {
+        ensureDir(dirname(path));
+        writeFileSync(path, next.endsWith("\n") ? next : next + "\n");
+    }
+    return true;
+}
+export function configureOpenCodeFile(path, mode) {
+    const current = readJsonWithComments(path);
+    if (!current.$schema) {
+        current.$schema = "https://opencode.ai/config.json";
+    }
+    const mcp = isRecord(current.mcp) ? current.mcp : {};
+    if (!isRecord(current.mcp)) {
+        current.mcp = mcp;
+    }
+    if (isOpenCodeAlmanacCurrent(mcp.almanac)) {
+        return false;
+    }
+    mcp.almanac = {
+        type: "local",
+        command: [ALMANAC_MCP_ENTRY.command, ...ALMANAC_MCP_ENTRY.args],
+        enabled: true,
+    };
+    if (mode === "apply") {
+        ensureDir(dirname(path));
+        writeJson(path, current);
+    }
+    return true;
+}
+export function readToml(path) {
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+export function readJsonWithComments(path) {
+    try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(stripJsonComments(raw));
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function stripJsonComments(input) {
+    let result = "";
+    let inString = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        const next = input[i + 1];
+        if (inLineComment) {
+            if (char === "\n") {
+                inLineComment = false;
+                result += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === "*" && next === "/") {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+        }
+        result += char;
+    }
+    return result;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function upsertCodexServer(content) {
+    const sectionName = "mcp_servers.almanac";
+    const header = `[${sectionName}]`;
+    const nextBody = [
+        `command = ${tomlString(ALMANAC_MCP_ENTRY.command)}`,
+        `args = ${tomlArray(ALMANAC_MCP_ENTRY.args)}`,
+    ];
+    const lines = content === "" ? [] : content.split(/\r?\n/);
+    const start = lines.findIndex((line) => line.trim() === header);
+    if (start === -1) {
+        const prefix = content.trimEnd();
+        const block = [header, ...nextBody].join("\n");
+        return prefix === "" ? block + "\n" : `${prefix}\n\n${block}\n`;
+    }
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        if (/^\s*\[.+\]\s*$/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    const existingBody = lines.slice(start + 1, end);
+    const preserved = existingBody.filter((line) => {
+        const trimmed = line.trim();
+        return !trimmed.startsWith("command =") && !trimmed.startsWith("args =");
+    });
+    const replacement = [header, ...nextBody, ...preserved];
+    const updated = [...lines.slice(0, start), ...replacement, ...lines.slice(end)];
+    return updated.join("\n").replace(/\n{3,}/g, "\n\n").replace(/\s+$/, "") + "\n";
+}
+export function tomlString(value) {
+    return JSON.stringify(value);
+}
+export function tomlArray(values) {
+    return `[${values.map((value) => tomlString(value)).join(", ")}]`;
+}

package/dist/setup/index.d.ts

@@ -0,0 +1,2 @@
+export { runRedditSetup } from "./reddit.js";
+export declare function runSetup(): Promise<void>;

package/dist/setup/index.js

@@ -0,0 +1,55 @@
+import { performLogin } from "../login-core.js";
+import { applyClientSetup, parseSetupArgs, printSetupPlan, resolveClients, } from "./clients.js";
+import { TOOL_GROUPS, configurePermissions } from "./permissions.js";
+import { printResult, runClientSelect, runLoginStep, runToolSelect } from "./tui.js";
+export { runRedditSetup } from "./reddit.js";
+export async function runSetup() {
+    const options = parseSetupArgs(process.argv.slice(3));
+    let clients = resolveClients(options);
+    if (options.print || options.dryRun) {
+        printSetupPlan(clients, options);
+        process.exit(0);
+    }
+    if (clients.length === 0) {
+        printSetupPlan(clients, options);
+        process.exit(0);
+    }
+    const skipTui = options.yes;
+    const interactive = process.stdin.isTTY && !skipTui;
+    if (interactive && options.clients.length === 0) {
+        clients = await runClientSelect(clients);
+    }
+    const clientsLabel = clients.map((client) => client.name).join(", ");
+    const setupSummary = applyClientSetup(clients, "apply");
+    const permissionClient = clients.find((client) => client.supportsPermissions);
+    let tools = [];
+    if (permissionClient) {
+        const mcpChanged = setupSummary.configured.includes(permissionClient.name);
+        if (interactive) {
+            tools = await runToolSelect(clientsLabel, mcpChanged);
+        }
+        else {
+            tools = TOOL_GROUPS.flatMap((g) => g.tools);
+        }
+    }
+    const count = tools.length > 0 ? configurePermissions(tools) : 0;
+    const permissionCount = permissionClient ? count : null;
+    let loginResult;
+    if (interactive) {
+        loginResult = await runLoginStep(clientsLabel, setupSummary.configured.length > 0, permissionCount);
+    }
+    else {
+        try {
+            const result = await performLogin();
+            loginResult =
+                result.status === "already_logged_in"
+                    ? { status: "already", name: result.name }
+                    : { status: "done" };
+        }
+        catch {
+            loginResult = { status: "skipped" };
+        }
+    }
+    printResult(clientsLabel, loginResult, setupSummary.configured, setupSummary.alreadyConfigured, count);
+    process.exit(0);
+}

package/dist/setup/permissions.d.ts

@@ -0,0 +1,3 @@
+import type { ToolGroup } from "./types.js";
+export declare const TOOL_GROUPS: ToolGroup[];
+export declare function configurePermissions(tools: string[]): number;