@gethmy/mcp 1.0.0 → 2.1.0

package/dist/lib/tui/theme.js

@@ -0,0 +1,95 @@
+import * as pc from "picocolors";
+/**
+ * Consistent theme for Harmony MCP TUI
+ * Uses picocolors for lightweight color output
+ */
+// Brand colors and symbols
+export const symbols = {
+    harmony: "\u25B2", // Triangle for Harmony logo
+    check: "\u2713",
+    cross: "\u2717",
+    bullet: "\u2022",
+    arrow: "\u2192",
+    arrowRight: "\u25B8",
+    dot: "\u25CF",
+    dotEmpty: "\u25CB",
+    info: "\u2139",
+    warning: "\u26A0",
+    pointer: "\u276F",
+};
+// Color functions
+export const colors = {
+    // Brand
+    brand: (text) => pc.cyan(text),
+    brandBold: (text) => pc.bold(pc.cyan(text)),
+    // Status
+    success: (text) => pc.green(text),
+    error: (text) => pc.red(text),
+    warning: (text) => pc.yellow(text),
+    info: (text) => pc.blue(text),
+    // Text
+    dim: (text) => pc.dim(text),
+    bold: (text) => pc.bold(text),
+    muted: (text) => pc.gray(text),
+    // Highlights
+    highlight: (text) => pc.cyan(text),
+    link: (text) => pc.underline(pc.cyan(text)),
+};
+// Styled messages
+export const messages = {
+    header: () => {
+        return `
+${colors.brandBold("  HARMONY")}
+${colors.dim("  Project management for AI agents")}
+`;
+    },
+    done: (message) => {
+        return `${colors.success(symbols.check)} ${message}`;
+    },
+    fail: (message) => {
+        return `${colors.error(symbols.cross)} ${message}`;
+    },
+    skip: (message) => {
+        return `${colors.dim("-")} ${colors.dim(message)}`;
+    },
+    step: (number, total, message) => {
+        return `${colors.dim(`[${number}/${total}]`)} ${message}`;
+    },
+    fileCreated: (path) => {
+        return `  ${colors.success(symbols.check)} ${colors.dim(path)}`;
+    },
+    fileSkipped: (path) => {
+        return `  ${colors.dim(symbols.bullet)} ${colors.dim(path)} ${colors.dim("(exists)")}`;
+    },
+    fileError: (path, error) => {
+        return `  ${colors.error(symbols.cross)} ${path}: ${colors.error(error)}`;
+    },
+};
+// Box drawing for sections
+export function box(title, content) {
+    const lines = content.split("\n");
+    const maxWidth = Math.max(title.length, ...lines.map((l) => l.length));
+    const width = maxWidth + 4;
+    const top = `\u250C${"─".repeat(width)}\u2510`;
+    const bottom = `\u2514${"─".repeat(width)}\u2518`;
+    const titleLine = `\u2502 ${colors.bold(title)}${" ".repeat(width - title.length - 1)}\u2502`;
+    const contentLines = lines
+        .map((line) => `\u2502 ${line}${" ".repeat(width - line.length - 1)}\u2502`)
+        .join("\n");
+    return `${top}\n${titleLine}\n${contentLines}\n${bottom}`;
+}
+// Format file paths for display (shorten home directory)
+export function formatPath(path, homeDir) {
+    if (path.startsWith(homeDir)) {
+        return `~${path.slice(homeDir.length)}`;
+    }
+    return path;
+}
+// Indent helper
+export function indent(text, spaces = 2) {
+    const pad = " ".repeat(spaces);
+    return text
+        .split("\n")
+        .map((line) => `${pad}${line}`)
+        .join("\n");
+}

package/dist/lib/tui/writer.js

@@ -0,0 +1,200 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname } from "node:path";
+import * as p from "@clack/prompts";
+import { colors, formatPath, messages } from "./theme.js";
+/**
+ * Ensure directory exists
+ */
+function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true, mode: 0o755 });
+    }
+}
+/**
+ * Write a file, optionally skipping if exists
+ */
+export function writeFile(filePath, content, options = {}) {
+    const exists = existsSync(filePath);
+    if (exists && !options.force) {
+        return { path: filePath, action: "skip" };
+    }
+    try {
+        ensureDir(dirname(filePath));
+        // Use restrictive permissions for config files
+        const mode = filePath.includes(".harmony-mcp") ? 0o600 : 0o644;
+        writeFileSync(filePath, content, { mode });
+        return { path: filePath, action: exists ? "update" : "create" };
+    }
+    catch (error) {
+        return {
+            path: filePath,
+            action: "skip",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Merge JSON content into existing file
+ */
+export function mergeJsonFile(filePath, updates, options = {}) {
+    const exists = existsSync(filePath);
+    if (!exists) {
+        try {
+            ensureDir(dirname(filePath));
+            writeFileSync(filePath, JSON.stringify(updates, null, 2), {
+                mode: 0o644,
+            });
+            return { path: filePath, action: "create" };
+        }
+        catch (error) {
+            return {
+                path: filePath,
+                action: "skip",
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    try {
+        const existing = JSON.parse(readFileSync(filePath, "utf-8"));
+        // Deep merge mcpServers if present (always update harmony config)
+        if (updates.mcpServers && existing.mcpServers) {
+            const existingServers = existing.mcpServers;
+            const updateServers = updates.mcpServers;
+            existing.mcpServers = { ...existingServers, ...updateServers };
+        }
+        else {
+            Object.assign(existing, updates);
+        }
+        writeFileSync(filePath, JSON.stringify(existing, null, 2), { mode: 0o644 });
+        return { path: filePath, action: "merge" };
+    }
+    catch {
+        if (options.force) {
+            try {
+                writeFileSync(filePath, JSON.stringify(updates, null, 2), {
+                    mode: 0o644,
+                });
+                return { path: filePath, action: "update" };
+            }
+            catch (error) {
+                return {
+                    path: filePath,
+                    action: "skip",
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }
+        return {
+            path: filePath,
+            action: "skip",
+            error: "Could not parse existing file",
+        };
+    }
+}
+/**
+ * Append to TOML file (for Codex config)
+ */
+export function appendToToml(filePath, section, content, options = {}) {
+    const exists = existsSync(filePath);
+    if (!exists) {
+        try {
+            ensureDir(dirname(filePath));
+            writeFileSync(filePath, content, { mode: 0o644 });
+            return { path: filePath, action: "create" };
+        }
+        catch (error) {
+            return {
+                path: filePath,
+                action: "skip",
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    try {
+        const existing = readFileSync(filePath, "utf-8");
+        if (existing.includes(section)) {
+            if (options.force) {
+                // Replace existing section
+                const updated = existing.replace(new RegExp(`\\[${section.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\][\\s\\S]*?(?=\\[|$)`), content.trim() + "\n\n");
+                writeFileSync(filePath, updated, { mode: 0o644 });
+                return { path: filePath, action: "update" };
+            }
+            return { path: filePath, action: "skip" };
+        }
+        // Append new section
+        writeFileSync(filePath, existing + "\n" + content, { mode: 0o644 });
+        return { path: filePath, action: "merge" };
+    }
+    catch (error) {
+        return {
+            path: filePath,
+            action: "skip",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Write multiple files with progress display
+ */
+export async function writeFilesWithProgress(files, options = {}) {
+    const results = [];
+    const home = homedir();
+    const spinner = p.spinner();
+    spinner.start("Writing configuration files...");
+    for (const file of files) {
+        let result;
+        if (file.type === "json") {
+            const jsonContent = JSON.parse(file.content);
+            result = mergeJsonFile(file.path, jsonContent, options);
+        }
+        else if (file.type === "toml" && file.tomlSection) {
+            result = appendToToml(file.path, file.tomlSection, file.content, options);
+        }
+        else {
+            result = writeFile(file.path, file.content, options);
+        }
+        results.push(result);
+        // Small delay for visual effect
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    spinner.stop("Files written");
+    // Display results
+    for (const result of results) {
+        const displayPath = formatPath(result.path, home);
+        if (result.error) {
+            console.log(messages.fileError(displayPath, result.error));
+        }
+        else if (result.action === "skip") {
+            console.log(messages.fileSkipped(displayPath));
+        }
+        else {
+            const actionLabel = result.action === "merge" ? "updated" : "created";
+            console.log(`  ${colors.success("\u2713")} ${colors.dim(displayPath)} ${colors.dim(`(${actionLabel})`)}`);
+        }
+    }
+    return results;
+}
+/**
+ * Get summary of what will be written
+ */
+export function getWriteSummary(files, options = {}) {
+    const toCreate = [];
+    const toUpdate = [];
+    const toSkip = [];
+    const home = homedir();
+    for (const file of files) {
+        const displayPath = formatPath(file.path, home);
+        const exists = existsSync(file.path);
+        if (exists && !options.force) {
+            toSkip.push(displayPath);
+        }
+        else if (exists) {
+            toUpdate.push(displayPath);
+        }
+        else {
+            toCreate.push(displayPath);
+        }
+    }
+    return { toCreate, toUpdate, toSkip };
+}