@anaclumos/taal 1.1.2

package/src/config/loader.ts

@@ -0,0 +1,88 @@
+import { exists, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parse } from "yaml";
+import { findEnvVarReferences, substituteEnvVars } from "./env.js";
+import { type TaalConfig, TaalConfigSchema } from "./schema.js";
+
+export interface LoadConfigResult {
+  config: TaalConfig | null;
+  errors: string[];
+  warnings: string[];
+}
+
+export async function loadTaalConfig(
+  baseDir?: string
+): Promise<LoadConfigResult> {
+  const home = baseDir || homedir();
+  const configPath = join(home, ".taal", "config.yaml");
+
+  const errors: string[] = [];
+  const warnings: string[] = [];
+
+  if (!(await exists(configPath))) {
+    return {
+      config: null,
+      errors: ["Config file not found"],
+      warnings: [],
+    };
+  }
+
+  let content: string;
+  try {
+    content = await readFile(configPath, "utf-8");
+  } catch (error) {
+    return {
+      config: null,
+      errors: [
+        `Failed to read config: ${error instanceof Error ? error.message : error}`,
+      ],
+      warnings: [],
+    };
+  }
+
+  let rawConfig: unknown;
+  try {
+    rawConfig = parse(content);
+  } catch (error) {
+    return {
+      config: null,
+      errors: [
+        `Failed to parse YAML: ${error instanceof Error ? error.message : error}`,
+      ],
+      warnings,
+    };
+  }
+
+  const envVarRefs = findEnvVarReferences(rawConfig);
+  for (const varName of envVarRefs) {
+    if (!process.env[varName]) {
+      warnings.push(`Environment variable ${varName} is not set`);
+    }
+  }
+
+  const configWithEnv = substituteEnvVars(rawConfig);
+  const result = TaalConfigSchema.safeParse(configWithEnv);
+
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      errors.push(`${issue.path.join(".")}: ${issue.message}`);
+    }
+    return {
+      config: null,
+      errors,
+      warnings,
+    };
+  }
+
+  return {
+    config: result.data,
+    errors: [],
+    warnings,
+  };
+}
+
+export function getConfigPath(baseDir?: string): string {
+  const home = baseDir || homedir();
+  return join(home, ".taal", "config.yaml");
+}

package/src/config/parser.ts

@@ -0,0 +1,44 @@
+import { readFileSync } from "node:fs";
+import { parse } from "yaml";
+import { substituteEnvVars } from "./env.js";
+import { type TaalConfig, TaalConfigSchema } from "./schema.js";
+
+/**
+ * Loads and validates TAAL configuration from a YAML file
+ *
+ * @param path - Path to the YAML configuration file
+ * @returns Validated TaalConfig object
+ * @throws Error if file cannot be read, YAML is invalid, or validation fails
+ */
+export function loadConfig(path: string): TaalConfig {
+  // 1. Read file
+  let fileContent: string;
+  try {
+    fileContent = readFileSync(path, "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to read config file at ${path}: ${error}`);
+  }
+
+  // 2. Parse YAML
+  let rawConfig: unknown;
+  try {
+    rawConfig = parse(fileContent);
+  } catch (error) {
+    throw new Error(`Failed to parse YAML in ${path}: ${error}`);
+  }
+
+  // 3. Substitute environment variables
+  const configWithEnv = substituteEnvVars(rawConfig);
+
+  // 4. Validate with Zod
+  const result = TaalConfigSchema.safeParse(configWithEnv);
+
+  if (!result.success) {
+    const errors = result.error.issues
+      .map((issue) => `  - ${issue.path.join(".")}: ${issue.message}`)
+      .join("\n");
+    throw new Error(`Config validation failed:\n${errors}`);
+  }
+
+  return result.data;
+}

package/src/config/schema.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+
+/**
+ * MCP Server Schema
+ * Supports either stdio (command-based) OR HTTP (url-based) servers, not both
+ */
+export const McpServerSchema = z
+  .object({
+    // Stdio server fields
+    command: z.string().optional(),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string()).optional(),
+
+    // HTTP server fields
+    url: z.string().optional(),
+    headers: z.record(z.string()).optional(),
+
+    // Provider-specific overrides
+    overrides: z
+      .record(
+        z.object({
+          enabled_tools: z.array(z.string()).optional(),
+        })
+      )
+      .optional(),
+  })
+  .refine(
+    (data) => {
+      const hasStdio = !!data.command;
+      const hasHttp = !!data.url;
+      // Must be either stdio OR http, not both, not neither
+      return (hasStdio && !hasHttp) || (hasHttp && !hasStdio);
+    },
+    {
+      message: "Server must be either stdio (command) or http (url), not both",
+    }
+  );
+
+/**
+ * Skills Configuration Schema
+ */
+export const SkillsConfigSchema = z.object({
+  paths: z.array(z.string()),
+});
+
+/**
+ * Providers Configuration Schema
+ */
+export const ProvidersConfigSchema = z.object({
+  enabled: z.array(z.string()),
+});
+
+/**
+ * TAAL Configuration Schema
+ */
+export const TaalConfigSchema = z.object({
+  version: z.literal("1"),
+  mcp: z.record(McpServerSchema).optional(),
+  skills: SkillsConfigSchema.optional(),
+  providers: ProvidersConfigSchema.optional(),
+});
+
+// Export inferred types
+export type McpServer = z.infer<typeof McpServerSchema>;
+export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
+export type ProvidersConfig = z.infer<typeof ProvidersConfigSchema>;
+export type TaalConfig = z.infer<typeof TaalConfigSchema>;

package/src/errors/index.ts

@@ -0,0 +1,43 @@
+export class TaalError extends Error {
+  readonly code: string;
+
+  constructor(message: string, code: string) {
+    super(message);
+    this.name = "TaalError";
+    this.code = code;
+  }
+}
+
+export class ConfigError extends TaalError {
+  constructor(message: string) {
+    super(message, "CONFIG_ERROR");
+    this.name = "ConfigError";
+  }
+}
+
+export class ProviderError extends TaalError {
+  readonly providerName: string;
+
+  constructor(message: string, providerName: string) {
+    super(message, "PROVIDER_ERROR");
+    this.name = "ProviderError";
+    this.providerName = providerName;
+  }
+}
+
+export class ValidationError extends TaalError {
+  readonly errors: string[];
+
+  constructor(message: string, errors: string[]) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+}
+
+export function formatError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}

package/src/index.ts

@@ -0,0 +1,301 @@
+#!/usr/bin/env bun
+import { exists, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+import YAML from "yaml";
+import { collect } from "./commands/collect";
+import { diff } from "./commands/diff";
+import { init } from "./commands/init";
+import { list } from "./commands/list";
+import { providers } from "./commands/providers";
+import { sync } from "./commands/sync";
+import { validate } from "./commands/validate";
+
+const program = new Command();
+
+program
+  .name("taal")
+  .description(
+    "CLI to sync MCP server configs and Agent Skills across AI providers"
+  )
+  .version("1.0.0");
+
+program
+  .command("init")
+  .description("Initialize TAAL configuration")
+  .option("-f, --force", "Overwrite existing configuration")
+  .action(async (options) => {
+    try {
+      await init(homedir(), options);
+      console.log("✓ TAAL initialized successfully");
+      console.log(`  Config: ${homedir()}/.taal/config.yaml`);
+      console.log(`  Skills: ${homedir()}/.taal/skills/`);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("collect")
+  .description("Import existing MCP configs from installed providers")
+  .action(async () => {
+    try {
+      console.log("Scanning installed providers...");
+      const result = await collect();
+
+      console.log(
+        `\n✓ Found ${result.summary.totalServers} servers from ${result.summary.providersWithConfigs} providers`
+      );
+
+      if (result.conflicts.length > 0) {
+        console.log("\n⚠ Conflicts detected:");
+        for (const conflict of result.conflicts) {
+          console.log(
+            `  - "${conflict.serverName}" found in: ${conflict.providers.join(", ")}`
+          );
+        }
+      }
+
+      const configPath = join(homedir(), ".taal", "config.yaml");
+      interface TaalConfigFile {
+        version: string;
+        mcp: Record<string, unknown>;
+        skills?: { paths: string[] };
+        providers?: { enabled: string[] };
+      }
+
+      let existingConfig: TaalConfigFile = {
+        version: "1",
+        mcp: {},
+        skills: { paths: ["~/.taal/skills"] },
+        providers: { enabled: [] },
+      };
+
+      if (await exists(configPath)) {
+        const content = await readFile(configPath, "utf-8");
+        existingConfig = YAML.parse(content) as TaalConfigFile;
+      }
+
+      existingConfig.mcp = { ...existingConfig.mcp, ...result.servers };
+
+      await writeFile(configPath, YAML.stringify(existingConfig), "utf-8");
+      console.log(`\n✓ Updated config: ${configPath}`);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("validate")
+  .description("Validate TAAL configuration")
+  .action(async () => {
+    try {
+      const result = await validate();
+
+      if (result.warnings.length > 0) {
+        console.log(chalk.yellow("\nWarnings:"));
+        for (const warning of result.warnings) {
+          console.log(chalk.yellow(`  ⚠ ${warning}`));
+        }
+      }
+
+      if (result.valid) {
+        console.log(chalk.green("\n✓ Configuration is valid"));
+        process.exit(0);
+      } else {
+        console.log(chalk.red("\n✗ Configuration is invalid\n"));
+        console.log(chalk.red("Errors:"));
+        for (const error of result.errors) {
+          console.log(chalk.red(`  • ${error}`));
+        }
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("diff [provider]")
+  .description("Show what would change without writing")
+  .action(async (provider?: string) => {
+    try {
+      const result = await diff(undefined, provider);
+
+      if (result.error) {
+        console.error(chalk.red(`Error: ${result.error}`));
+        process.exit(1);
+      }
+
+      if (!result.hasChanges) {
+        console.log(chalk.green("\n✓ No changes detected"));
+        process.exit(0);
+      }
+
+      console.log(chalk.bold("\nChanges:\n"));
+
+      const byProvider = new Map<string, typeof result.changes>();
+      for (const change of result.changes) {
+        if (!byProvider.has(change.provider)) {
+          byProvider.set(change.provider, []);
+        }
+        byProvider.get(change.provider)?.push(change);
+      }
+
+      for (const [providerName, changes] of byProvider) {
+        console.log(chalk.bold(`${providerName}:`));
+        for (const change of changes) {
+          if (change.type === "add") {
+            console.log(chalk.green(`  + ${change.serverName}`));
+          } else if (change.type === "remove") {
+            console.log(chalk.red(`  - ${change.serverName}`));
+          } else {
+            console.log(chalk.yellow(`  ~ ${change.serverName}`));
+          }
+        }
+        console.log();
+      }
+
+      process.exit(1);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("sync [provider]")
+  .description("Sync MCP configs and skills to providers")
+  .action(async (provider?: string) => {
+    try {
+      console.log(chalk.bold("Syncing..."));
+      const result = await sync(undefined, provider);
+
+      if (result.error) {
+        console.error(chalk.red(`\nError: ${result.error}`));
+        process.exit(1);
+      }
+
+      if (result.synced.length > 0) {
+        console.log(
+          chalk.green(`\n✓ Synced to ${result.synced.length} provider(s):`)
+        );
+        for (const p of result.synced) {
+          console.log(chalk.green(`  • ${p}`));
+        }
+      }
+
+      if (result.failed.length > 0) {
+        console.log(
+          chalk.red(`\n✗ Failed to sync ${result.failed.length} provider(s):`)
+        );
+        for (const f of result.failed) {
+          console.log(chalk.red(`  • ${f.provider}: ${f.error}`));
+        }
+      }
+
+      process.exit(result.success ? 0 : 1);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("list")
+  .description("List configured MCP servers and skills")
+  .action(async () => {
+    try {
+      const result = await list();
+
+      if (result.error) {
+        console.error(chalk.red(`Error: ${result.error}`));
+        process.exit(1);
+      }
+
+      console.log(chalk.bold("\nMCP Servers:\n"));
+      if (result.servers.length === 0) {
+        console.log(chalk.dim("  No servers configured"));
+      } else {
+        for (const server of result.servers) {
+          const type =
+            server.type === "stdio"
+              ? chalk.blue("[stdio]")
+              : chalk.green("[http]");
+          const detail = server.command || server.url || "";
+          console.log(
+            `  ${type} ${chalk.bold(server.name)} ${chalk.dim(detail)}`
+          );
+        }
+      }
+
+      console.log(chalk.bold("\nSkills:\n"));
+      if (result.skills.length === 0) {
+        console.log(chalk.dim("  No skills found"));
+      } else {
+        for (const skill of result.skills) {
+          console.log(`  • ${chalk.bold(skill.name)} ${chalk.dim(skill.path)}`);
+        }
+      }
+
+      console.log(chalk.bold("\nEnabled Providers:\n"));
+      if (result.enabledProviders.length === 0) {
+        console.log(chalk.dim("  No providers enabled"));
+      } else {
+        for (const provider of result.enabledProviders) {
+          console.log(`  • ${provider}`);
+        }
+      }
+
+      console.log();
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("providers")
+  .description("List all supported providers")
+  .action(async () => {
+    try {
+      const result = await providers();
+
+      console.log(chalk.bold("\nSupported Providers:\n"));
+
+      for (const provider of result.providers) {
+        const status: string[] = [];
+
+        if (provider.installed) {
+          status.push(chalk.green("installed"));
+        } else {
+          status.push(chalk.dim("not installed"));
+        }
+
+        if (provider.enabled) {
+          status.push(chalk.blue("enabled"));
+        } else {
+          status.push(chalk.dim("disabled"));
+        }
+
+        const format = chalk.yellow(`[${provider.format}]`);
+
+        console.log(
+          `  ${chalk.bold(provider.name)} ${format} ${status.join(", ")}`
+        );
+        console.log(chalk.dim(`    ${provider.configPath}`));
+      }
+
+      console.log();
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/providers/antigravity.ts

@@ -0,0 +1,24 @@
+import { platform } from "node:os";
+import { join } from "node:path";
+import { BaseProvider, createStdioTransformer } from "./base.js";
+
+export class AntigravityProvider extends BaseProvider {
+  name = "antigravity";
+  configPath = (home: string) => {
+    const os = platform();
+    if (os === "darwin") {
+      return join(
+        home,
+        "Library",
+        "Application Support",
+        "Antigravity",
+        "settings.json"
+      );
+    }
+    return join(home, ".config", "antigravity", "settings.json");
+  };
+  format = "json" as const;
+  mcpKey = "mcpServers";
+
+  transformMcpServers = createStdioTransformer("Antigravity");
+}

package/src/providers/base.ts

@@ -0,0 +1,70 @@
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname } from "node:path";
+import type { McpServer } from "../config/schema.js";
+import type { ConfigFormat, Provider } from "./types.js";
+import {
+  readConfig,
+  resolveConfigPath,
+  writeConfig as writeConfigUtil,
+} from "./utils.js";
+
+export abstract class BaseProvider implements Provider {
+  abstract name: string;
+  abstract configPath: string | ((home: string) => string);
+  abstract format: ConfigFormat;
+  abstract mcpKey: string;
+  skillsPath?: string | ((home: string) => string);
+
+  async isInstalled(home?: string): Promise<boolean> {
+    const homeDir = home || homedir();
+    const configDir = dirname(resolveConfigPath(this.configPath, homeDir));
+    return existsSync(configDir);
+  }
+
+  async readConfig(home?: string): Promise<unknown> {
+    const homeDir = home || homedir();
+    const path = resolveConfigPath(this.configPath, homeDir);
+    return readConfig(path, this.format);
+  }
+
+  async writeConfig(config: unknown, home?: string): Promise<void> {
+    const homeDir = home || homedir();
+    const path = resolveConfigPath(this.configPath, homeDir);
+    writeConfigUtil(path, this.format, config);
+  }
+
+  abstract transformMcpServers(
+    servers: Record<string, McpServer>
+  ): Record<string, unknown> | unknown[];
+}
+
+export function createStdioTransformer(providerName: string) {
+  return function transformMcpServers(
+    servers: Record<string, McpServer>
+  ): Record<string, unknown> {
+    const transformed: Record<string, unknown> = {};
+
+    for (const [name, server] of Object.entries(servers)) {
+      if (server.url) {
+        console.warn(
+          `Skipping HTTP server "${name}" - ${providerName} only supports stdio servers`
+        );
+        continue;
+      }
+
+      if (!server.command) {
+        console.warn(`Skipping server "${name}" - missing command`);
+        continue;
+      }
+
+      transformed[name] = {
+        command: server.command,
+        ...(server.args && { args: server.args }),
+        ...(server.env && { env: server.env }),
+      };
+    }
+
+    return transformed;
+  };
+}

package/src/providers/claude-code.ts

@@ -0,0 +1,12 @@
+import { join } from "node:path";
+import { BaseProvider, createStdioTransformer } from "./base.js";
+
+export class ClaudeCodeProvider extends BaseProvider {
+  name = "claude-code";
+  configPath = (home: string) => join(home, ".claude", "settings.json");
+  format = "json" as const;
+  mcpKey = "mcpServers";
+  skillsPath = (home: string) => join(home, ".claude", "skills");
+
+  transformMcpServers = createStdioTransformer("Claude Code");
+}

package/src/providers/claude-desktop.ts

@@ -0,0 +1,19 @@
+import { join } from "node:path";
+import { BaseProvider, createStdioTransformer } from "./base.js";
+
+export class ClaudeDesktopProvider extends BaseProvider {
+  name = "claude-desktop";
+  configPath = (home: string) =>
+    join(
+      home,
+      "Library",
+      "Application Support",
+      "Claude",
+      "claude_desktop_config.json"
+    );
+  format = "json" as const;
+  mcpKey = "mcpServers";
+  skillsPath = (home: string) => join(home, ".claude", "skills");
+
+  transformMcpServers = createStdioTransformer("Claude Desktop");
+}