@gethmy/mcp 2.0.0 → 2.1.1

package/src/tui/theme.ts

@@ -0,0 +1,114 @@
+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: string) => pc.cyan(text),
+  brandBold: (text: string) => pc.bold(pc.cyan(text)),
+
+  // Status
+  success: (text: string) => pc.green(text),
+  error: (text: string) => pc.red(text),
+  warning: (text: string) => pc.yellow(text),
+  info: (text: string) => pc.blue(text),
+
+  // Text
+  dim: (text: string) => pc.dim(text),
+  bold: (text: string) => pc.bold(text),
+  muted: (text: string) => pc.gray(text),
+
+  // Highlights
+  highlight: (text: string) => pc.cyan(text),
+  link: (text: string) => pc.underline(pc.cyan(text)),
+};
+
+// Styled messages
+export const messages = {
+  header: () => {
+    return `
+${colors.brandBold("  HARMONY")}
+${colors.dim("  Project management for AI agents")}
+`;
+  },
+
+  done: (message: string) => {
+    return `${colors.success(symbols.check)} ${message}`;
+  },
+
+  fail: (message: string) => {
+    return `${colors.error(symbols.cross)} ${message}`;
+  },
+
+  skip: (message: string) => {
+    return `${colors.dim("-")} ${colors.dim(message)}`;
+  },
+
+  step: (number: number, total: number, message: string) => {
+    return `${colors.dim(`[${number}/${total}]`)} ${message}`;
+  },
+
+  fileCreated: (path: string) => {
+    return `  ${colors.success(symbols.check)} ${colors.dim(path)}`;
+  },
+
+  fileSkipped: (path: string) => {
+    return `  ${colors.dim(symbols.bullet)} ${colors.dim(path)} ${colors.dim("(exists)")}`;
+  },
+
+  fileError: (path: string, error: string) => {
+    return `  ${colors.error(symbols.cross)} ${path}: ${colors.error(error)}`;
+  },
+};
+
+// Box drawing for sections
+export function box(title: string, content: string): string {
+  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: string, homeDir: string): string {
+  if (path.startsWith(homeDir)) {
+    return `~${path.slice(homeDir.length)}`;
+  }
+  return path;
+}
+
+// Indent helper
+export function indent(text: string, spaces = 2): string {
+  const pad = " ".repeat(spaces);
+  return text
+    .split("\n")
+    .map((line) => `${pad}${line}`)
+    .join("\n");
+}

package/src/tui/writer.ts

@@ -0,0 +1,260 @@
+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";
+
+export type FileAction = "create" | "update" | "merge" | "skip";
+
+export interface FileResult {
+  path: string;
+  action: FileAction;
+  error?: string;
+}
+
+interface WriteOptions {
+  force?: boolean;
+  merge?: boolean;
+}
+
+/**
+ * Ensure directory exists
+ */
+function ensureDir(dirPath: string): void {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true, mode: 0o755 });
+  }
+}
+
+/**
+ * Write a file, optionally skipping if exists
+ */
+export function writeFile(
+  filePath: string,
+  content: string,
+  options: WriteOptions = {},
+): FileResult {
+  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: string,
+  updates: Record<string, unknown>,
+  options: WriteOptions = {},
+): FileResult {
+  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 as Record<string, unknown>;
+      const updateServers = updates.mcpServers as Record<string, unknown>;
+      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: string,
+  section: string,
+  content: string,
+  options: WriteOptions = {},
+): FileResult {
+  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: Array<{
+    path: string;
+    content: string;
+    type: "text" | "json" | "toml";
+    jsonKey?: string;
+    tomlSection?: string;
+  }>,
+  options: WriteOptions = {},
+): Promise<FileResult[]> {
+  const results: FileResult[] = [];
+  const home = homedir();
+
+  const spinner = p.spinner();
+  spinner.start("Writing configuration files...");
+
+  for (const file of files) {
+    let result: FileResult;
+
+    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: Array<{ path: string; type: string }>,
+  options: WriteOptions = {},
+): { toCreate: string[]; toUpdate: string[]; toSkip: string[] } {
+  const toCreate: string[] = [];
+  const toUpdate: string[] = [];
+  const toSkip: string[] = [];
+  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 };
+}