@anaclumos/taal 1.1.2

package/src/commands/collect.ts

@@ -0,0 +1,172 @@
+import { homedir } from "node:os";
+import type { McpServer } from "../config/schema.js";
+import { initializeProviders, registry } from "../providers/index.js";
+
+export interface CollectConflict {
+  serverName: string;
+  providers: string[];
+  configs: unknown[];
+}
+
+export interface CollectResult {
+  servers: Record<string, McpServer>;
+  conflicts: CollectConflict[];
+  summary: {
+    totalServers: number;
+    providersScanned: number;
+    providersWithConfigs: number;
+  };
+}
+
+/**
+ * Collect MCP server configs from all installed providers
+ */
+export async function collect(baseDir?: string): Promise<CollectResult> {
+  initializeProviders();
+  const home = baseDir || homedir();
+  const servers: Record<string, McpServer> = {};
+  const conflicts: CollectConflict[] = [];
+  const serverSources = new Map<
+    string,
+    { provider: string; config: unknown }[]
+  >();
+
+  let providersScanned = 0;
+  let providersWithConfigs = 0;
+
+  const allProviders = registry.getAll();
+
+  for (const provider of allProviders) {
+    providersScanned++;
+
+    try {
+      // Check if provider is installed
+      const isInstalled = await provider.isInstalled(home);
+      if (!isInstalled) {
+        continue;
+      }
+
+      // Read provider config
+      const config = await provider.readConfig(home);
+      if (!config || typeof config !== "object") {
+        continue;
+      }
+
+      // Extract MCP servers from config
+      const mcpServers = (config as Record<string, unknown>)[provider.mcpKey];
+      if (!mcpServers || typeof mcpServers !== "object") {
+        continue;
+      }
+
+      providersWithConfigs++;
+
+      // Process each server
+      for (const [serverName, serverConfig] of Object.entries(mcpServers)) {
+        // Track source for conflict detection
+        if (!serverSources.has(serverName)) {
+          serverSources.set(serverName, []);
+        }
+        serverSources.get(serverName)?.push({
+          provider: provider.name,
+          config: serverConfig,
+        });
+
+        // Convert to TAAL format
+        const taalServer = convertToTaalFormat(serverConfig);
+        if (taalServer) {
+          servers[serverName] = taalServer;
+        }
+      }
+    } catch (error) {
+      // Skip providers that fail to read
+      console.warn(
+        `Warning: Failed to read config from ${provider.name}:`,
+        error
+      );
+    }
+  }
+
+  // Detect conflicts
+  for (const [serverName, sources] of serverSources.entries()) {
+    if (sources.length > 1) {
+      // Check if configs are actually different
+      const configStrings = sources.map((s) => JSON.stringify(s.config));
+      const uniqueConfigs = new Set(configStrings);
+
+      if (uniqueConfigs.size > 1) {
+        conflicts.push({
+          serverName,
+          providers: sources.map((s) => s.provider),
+          configs: sources.map((s) => s.config),
+        });
+      }
+    }
+  }
+
+  return {
+    servers,
+    conflicts,
+    summary: {
+      totalServers: Object.keys(servers).length,
+      providersScanned,
+      providersWithConfigs,
+    },
+  };
+}
+
+/**
+ * Convert provider-specific server config to TAAL format
+ */
+function convertToTaalFormat(config: unknown): McpServer | null {
+  if (!config || typeof config !== "object") {
+    return null;
+  }
+
+  const obj = config as Record<string, unknown>;
+
+  // HTTP server
+  if (obj.url && typeof obj.url === "string") {
+    return {
+      url: obj.url,
+      headers:
+        (obj.headers as Record<string, string>) ||
+        (obj.http_headers as Record<string, string>),
+    };
+  }
+
+  // Stdio server
+  if (obj.command && typeof obj.command === "string") {
+    const server: McpServer = {
+      command: obj.command,
+    };
+
+    if (Array.isArray(obj.args)) {
+      server.args = obj.args as string[];
+    }
+
+    if (obj.env && typeof obj.env === "object") {
+      server.env = obj.env as Record<string, string>;
+    } else if (obj.environment && typeof obj.environment === "object") {
+      server.env = obj.environment as Record<string, string>;
+    }
+
+    return server;
+  }
+
+  // OpenCode format with command array
+  if (Array.isArray(obj.command) && obj.command.length > 0) {
+    const [cmd, ...args] = obj.command as string[];
+    const server: McpServer = {
+      command: cmd,
+      args,
+    };
+
+    if (obj.environment && typeof obj.environment === "object") {
+      server.env = obj.environment as Record<string, string>;
+    }
+
+    return server;
+  }
+
+  return null;
+}

package/src/commands/diff.ts

@@ -0,0 +1,127 @@
+import { homedir } from "node:os";
+import { loadTaalConfig } from "../config/loader.js";
+import { initializeProviders, registry } from "../providers/index.js";
+
+export interface DiffChange {
+  type: "add" | "remove" | "modify";
+  serverName: string;
+  provider: string;
+  oldValue?: unknown;
+  newValue?: unknown;
+}
+
+export interface DiffResult {
+  hasChanges: boolean;
+  changes: DiffChange[];
+  provider?: string;
+  error?: string;
+}
+
+export async function diff(
+  baseDir?: string,
+  providerName?: string
+): Promise<DiffResult> {
+  initializeProviders();
+  const home = baseDir || homedir();
+
+  const result = await loadTaalConfig(baseDir);
+
+  if (!result.config) {
+    return {
+      hasChanges: false,
+      changes: [],
+      error: result.errors[0] || "Config file not found",
+    };
+  }
+
+  const config = result.config;
+
+  try {
+    const changes: DiffChange[] = [];
+
+    const providers = providerName
+      ? [registry.get(providerName)].filter(Boolean)
+      : registry.getAll();
+
+    for (const provider of providers) {
+      if (!provider) {
+        continue;
+      }
+
+      const isInstalled = await provider.isInstalled(home);
+      if (!isInstalled) {
+        continue;
+      }
+
+      const enabledProviders = config.providers?.enabled || [];
+      if (!enabledProviders.includes(provider.name)) {
+        continue;
+      }
+
+      try {
+        const currentConfig = await provider.readConfig(home);
+        const currentServers: Record<string, unknown> =
+          ((currentConfig as Record<string, unknown>)?.[
+            provider.mcpKey
+          ] as Record<string, unknown>) || {};
+
+        const taalServers = config.mcp || {};
+        const transformedServers = provider.transformMcpServers(taalServers);
+
+        const currentKeys = new Set(Object.keys(currentServers));
+        const taalKeys = new Set(Object.keys(transformedServers as object));
+
+        for (const key of taalKeys) {
+          if (currentKeys.has(key)) {
+            const currentValue = JSON.stringify(currentServers[key]);
+            const newValue = JSON.stringify(
+              (transformedServers as Record<string, unknown>)[key]
+            );
+
+            if (currentValue !== newValue) {
+              changes.push({
+                type: "modify",
+                serverName: key,
+                provider: provider.name,
+                oldValue: currentServers[key],
+                newValue: (transformedServers as Record<string, unknown>)[key],
+              });
+            }
+          } else {
+            changes.push({
+              type: "add",
+              serverName: key,
+              provider: provider.name,
+              newValue: (transformedServers as Record<string, unknown>)[key],
+            });
+          }
+        }
+
+        for (const key of currentKeys) {
+          if (!taalKeys.has(key)) {
+            changes.push({
+              type: "remove",
+              serverName: key,
+              provider: provider.name,
+              oldValue: currentServers[key],
+            });
+          }
+        }
+      } catch (_error) {
+        // Ignore provider read errors - continue with other providers
+      }
+    }
+
+    return {
+      hasChanges: changes.length > 0,
+      changes,
+      provider: providerName,
+    };
+  } catch (error) {
+    return {
+      hasChanges: false,
+      changes: [],
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,66 @@
+import { exists, mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const SAMPLE_CONFIG = `# TAAL Configuration
+# https://github.com/user/taal
+
+version: "1"
+
+mcp: {}
+  # Example stdio server
+  # example-server:
+  #   command: npx
+  #   args: ["-y", "@example/mcp-server"]
+  #   env:
+  #     API_KEY: "\${API_KEY}"
+  
+  # Example HTTP server
+  # context7:
+  #   url: https://mcp.context7.com/mcp
+  #   headers:
+  #     CONTEXT7_API_KEY: "\${CONTEXT7_API_KEY}"
+
+skills:
+  paths:
+    - ~/.taal/skills
+
+providers:
+  enabled:
+    - claude-desktop
+    - claude-code
+    - cursor
+    - continue
+    - zed
+    - opencode
+    - codex
+    - windsurf
+    - antigravity
+`;
+
+export interface InitOptions {
+  force?: boolean;
+}
+
+export async function init(
+  baseDir?: string,
+  options: InitOptions = {}
+): Promise<void> {
+  const taalDir = join(baseDir || homedir(), ".taal");
+  const configPath = join(taalDir, "config.yaml");
+  const skillsDir = join(taalDir, "skills");
+  const backupsDir = join(taalDir, "backups");
+
+  // Check if already initialized
+  if ((await exists(configPath)) && !options.force) {
+    throw new Error("TAAL is already initialized. Use --force to overwrite.");
+  }
+
+  // Create directories
+  await mkdir(taalDir, { recursive: true });
+  await mkdir(skillsDir, { recursive: true });
+  await mkdir(backupsDir, { recursive: true });
+
+  // Write sample config
+  await writeFile(configPath, SAMPLE_CONFIG, "utf-8");
+}

package/src/commands/list.ts

@@ -0,0 +1,80 @@
+import { homedir } from "node:os";
+import { loadTaalConfig } from "../config/loader.js";
+import { discoverSkills } from "../skills/discovery.js";
+
+export interface ServerInfo {
+  name: string;
+  type: "stdio" | "http";
+  command?: string;
+  url?: string;
+}
+
+export interface SkillInfo {
+  name: string;
+  path: string;
+}
+
+export interface ListResult {
+  servers: ServerInfo[];
+  skills: SkillInfo[];
+  enabledProviders: string[];
+  error?: string;
+}
+
+export async function list(baseDir?: string): Promise<ListResult> {
+  const home = baseDir || homedir();
+  const result = await loadTaalConfig(baseDir);
+
+  if (!result.config) {
+    return {
+      servers: [],
+      skills: [],
+      enabledProviders: [],
+      error: result.errors[0] || "Config file not found",
+    };
+  }
+
+  const config = result.config;
+
+  try {
+    const servers: ServerInfo[] = [];
+    for (const [name, server] of Object.entries(config.mcp || {})) {
+      if (server.url) {
+        servers.push({
+          name,
+          type: "http",
+          url: server.url,
+        });
+      } else if (server.command) {
+        servers.push({
+          name,
+          type: "stdio",
+          command: server.command,
+        });
+      }
+    }
+
+    const skillPaths = config.skills?.paths || [];
+    const discoveredSkills = await discoverSkills(skillPaths, home);
+
+    const skills: SkillInfo[] = discoveredSkills.map((skill) => ({
+      name: skill.name,
+      path: skill.path,
+    }));
+
+    const enabledProviders = config.providers?.enabled || [];
+
+    return {
+      servers,
+      skills,
+      enabledProviders,
+    };
+  } catch (error) {
+    return {
+      servers: [],
+      skills: [],
+      enabledProviders: [],
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/src/commands/providers.ts

@@ -0,0 +1,46 @@
+import { homedir } from "node:os";
+import { loadTaalConfig } from "../config/loader.js";
+import { initializeProviders, registry } from "../providers/index.js";
+
+export interface ProviderInfo {
+  name: string;
+  configPath: string;
+  format: string;
+  installed: boolean;
+  enabled: boolean;
+}
+
+export interface ProvidersResult {
+  providers: ProviderInfo[];
+}
+
+export async function providers(baseDir?: string): Promise<ProvidersResult> {
+  initializeProviders();
+  const home = baseDir || homedir();
+
+  const result = await loadTaalConfig(baseDir);
+  const enabledProviders = result.config?.providers?.enabled || [];
+
+  const allProviders = registry.getAll();
+  const providerInfos: ProviderInfo[] = [];
+
+  for (const provider of allProviders) {
+    const installed = await provider.isInstalled(home);
+    const configPathResolved =
+      typeof provider.configPath === "function"
+        ? provider.configPath(home)
+        : provider.configPath;
+
+    providerInfos.push({
+      name: provider.name,
+      configPath: configPathResolved,
+      format: provider.format,
+      installed,
+      enabled: enabledProviders.includes(provider.name),
+    });
+  }
+
+  return {
+    providers: providerInfos,
+  };
+}

package/src/commands/sync.ts

@@ -0,0 +1,111 @@
+import { homedir } from "node:os";
+import { loadTaalConfig } from "../config/loader.js";
+import { initializeProviders, registry } from "../providers/index.js";
+import { copySkillsToProvider } from "../skills/copy.js";
+import { discoverSkills } from "../skills/discovery.js";
+import { backupConfig } from "../utils/backup.js";
+
+export interface SyncResult {
+  success: boolean;
+  synced: string[];
+  failed: Array<{ provider: string; error: string }>;
+  error?: string;
+}
+
+export async function sync(
+  baseDir?: string,
+  providerName?: string
+): Promise<SyncResult> {
+  initializeProviders();
+  const home = baseDir || homedir();
+
+  const result = await loadTaalConfig(baseDir);
+
+  if (!result.config) {
+    return {
+      success: false,
+      synced: [],
+      failed: [],
+      error: result.errors[0] || "Config file not found",
+    };
+  }
+
+  const config = result.config;
+
+  try {
+    const synced: string[] = [];
+    const failed: Array<{ provider: string; error: string }> = [];
+
+    const providers = providerName
+      ? [registry.get(providerName)].filter(Boolean)
+      : registry.getAll();
+
+    const enabledProviders = config.providers?.enabled || [];
+
+    for (const provider of providers) {
+      if (!provider) {
+        continue;
+      }
+
+      if (!enabledProviders.includes(provider.name)) {
+        continue;
+      }
+
+      try {
+        const isInstalled = await provider.isInstalled(home);
+        if (!isInstalled) {
+          continue;
+        }
+
+        const currentConfig = await provider.readConfig(home);
+
+        await backupConfig(
+          typeof provider.configPath === "function"
+            ? provider.configPath(home)
+            : provider.configPath,
+          home
+        );
+
+        const taalServers = config.mcp || {};
+        const transformedServers = provider.transformMcpServers(taalServers);
+
+        const newConfig = {
+          ...(currentConfig as object),
+          [provider.mcpKey]: transformedServers,
+        };
+
+        await provider.writeConfig(newConfig, home);
+
+        if (provider.skillsPath && config.skills?.paths) {
+          const allSkills = await discoverSkills(config.skills.paths, home);
+          const skillsPath =
+            typeof provider.skillsPath === "function"
+              ? provider.skillsPath(home)
+              : provider.skillsPath;
+
+          await copySkillsToProvider(allSkills, skillsPath);
+        }
+
+        synced.push(provider.name);
+      } catch (error) {
+        failed.push({
+          provider: provider.name,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    return {
+      success: failed.length === 0,
+      synced,
+      failed,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      synced: [],
+      failed: [],
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}

package/src/commands/validate.ts

@@ -0,0 +1,17 @@
+import { loadTaalConfig } from "../config/loader.js";
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+export async function validate(baseDir?: string): Promise<ValidationResult> {
+  const result = await loadTaalConfig(baseDir);
+
+  return {
+    valid: result.config !== null && result.errors.length === 0,
+    errors: result.errors,
+    warnings: result.warnings,
+  };
+}

package/src/config/env.ts

@@ -0,0 +1,49 @@
+export function findEnvVarReferences(value: unknown): string[] {
+  const refs = new Set<string>();
+
+  if (typeof value === "string") {
+    const matches = value.matchAll(/\$\{([^}]+)\}/g);
+    for (const match of matches) {
+      refs.add(match[1]);
+    }
+  } else if (Array.isArray(value)) {
+    for (const item of value) {
+      for (const ref of findEnvVarReferences(item)) {
+        refs.add(ref);
+      }
+    }
+  } else if (value && typeof value === "object") {
+    for (const v of Object.values(value)) {
+      for (const ref of findEnvVarReferences(v)) {
+        refs.add(ref);
+      }
+    }
+  }
+
+  return Array.from(refs);
+}
+
+export function substituteEnvVars(value: unknown): unknown {
+  if (typeof value === "string") {
+    return value.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+      const envValue = process.env[varName];
+      if (envValue === undefined) {
+        console.warn(`Warning: Environment variable ${varName} is not set`);
+        return match;
+      }
+      return envValue;
+    });
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(substituteEnvVars);
+  }
+
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [k, substituteEnvVars(v)])
+    );
+  }
+
+  return value;
+}