@anaclumos/taal 1.1.2

package/src/providers/codex.ts

@@ -0,0 +1,61 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { JsonMap } from "@iarna/toml";
+import { stringify as stringifyToml } from "@iarna/toml";
+import type { McpServer } from "../config/schema.js";
+import { atomicWrite } from "../utils/atomic-write.js";
+import { backupConfig } from "../utils/backup.js";
+import { BaseProvider } from "./base.js";
+import { resolveConfigPath } from "./utils.js";
+
+export class CodexProvider extends BaseProvider {
+  name = "codex";
+  configPath = (home: string) => join(home, ".codex", "config.toml");
+  format = "toml" as const;
+  mcpKey = "mcp_servers";
+  skillsPath = (home: string) => join(home, ".codex", "skills");
+
+  override async writeConfig(config: unknown, home?: string): Promise<void> {
+    const homeDir = home || homedir();
+    const path = resolveConfigPath(this.configPath, homeDir);
+
+    backupConfig(path);
+
+    const tomlContent = stringifyToml(config as JsonMap);
+    atomicWrite(path, tomlContent);
+  }
+
+  transformMcpServers(
+    servers: Record<string, McpServer>
+  ): Record<string, unknown> {
+    const transformed: Record<string, unknown> = {};
+
+    for (const [name, server] of Object.entries(servers)) {
+      if (server.url) {
+        transformed[name] = {
+          url: server.url,
+          ...(server.headers && { http_headers: server.headers }),
+          enabled: true,
+          startup_timeout_sec: 30,
+          ...(server.overrides?.codex?.enabled_tools && {
+            enabled_tools: server.overrides.codex.enabled_tools,
+          }),
+        };
+      } else if (server.command) {
+        transformed[name] = {
+          command: server.command,
+          ...(server.args && { args: server.args }),
+          ...(server.env && { env: server.env }),
+          enabled: true,
+          ...(server.overrides?.codex?.enabled_tools && {
+            enabled_tools: server.overrides.codex.enabled_tools,
+          }),
+        };
+      } else {
+        console.warn(`Skipping server "${name}" - missing command or url`);
+      }
+    }
+
+    return transformed;
+  }
+}

package/src/providers/continue.ts

@@ -0,0 +1,62 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { stringify as stringifyYaml } from "yaml";
+import type { McpServer } from "../config/schema.js";
+import { atomicWrite } from "../utils/atomic-write.js";
+import { backupConfig } from "../utils/backup.js";
+import { BaseProvider } from "./base.js";
+import { resolveConfigPath } from "./utils.js";
+
+export class ContinueProvider extends BaseProvider {
+  name = "continue";
+  configPath = (home: string) => join(home, ".continue", "config.yaml");
+  format = "yaml" as const;
+  mcpKey = "mcpServers";
+
+  override async writeConfig(config: unknown, home?: string): Promise<void> {
+    const homeDir = home || homedir();
+    const path = resolveConfigPath(this.configPath, homeDir);
+
+    backupConfig(path);
+
+    const yamlContent = stringifyYaml(config);
+    atomicWrite(path, yamlContent);
+  }
+
+  transformMcpServers(servers: Record<string, McpServer>): unknown[] {
+    const transformed: unknown[] = [];
+
+    for (const [name, server] of Object.entries(servers)) {
+      if (server.url) {
+        transformed.push({
+          name,
+          url: server.url,
+          ...(server.headers && {
+            headers: this.transformEnvVars(server.headers),
+          }),
+        });
+      } else if (server.command) {
+        transformed.push({
+          name,
+          command: server.command,
+          ...(server.args && { args: server.args }),
+          ...(server.env && { env: this.transformEnvVars(server.env) }),
+        });
+      } else {
+        console.warn(`Skipping server "${name}" - missing command or url`);
+      }
+    }
+
+    return transformed;
+  }
+
+  private transformEnvVars(
+    obj: Record<string, string>
+  ): Record<string, string> {
+    const transformed: Record<string, string> = {};
+    for (const [key, value] of Object.entries(obj)) {
+      transformed[key] = value.replace(/\$\{([^}]+)\}/g, "${{ secrets.$1 }}");
+    }
+    return transformed;
+  }
+}

package/src/providers/cursor.ts

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

package/src/providers/index.ts

@@ -0,0 +1,34 @@
+import { AntigravityProvider } from "./antigravity.js";
+import { ClaudeCodeProvider } from "./claude-code.js";
+import { ClaudeDesktopProvider } from "./claude-desktop.js";
+import { CodexProvider } from "./codex.js";
+import { ContinueProvider } from "./continue.js";
+import { CursorProvider } from "./cursor.js";
+import { OpenCodeProvider } from "./opencode.js";
+import { registry as providerRegistry } from "./registry.js";
+import { WindsurfProvider } from "./windsurf.js";
+import { ZedProvider } from "./zed.js";
+
+let initialized = false;
+
+export function initializeProviders(): void {
+  if (initialized) {
+    return;
+  }
+
+  providerRegistry.register(new ClaudeDesktopProvider());
+  providerRegistry.register(new ClaudeCodeProvider());
+  providerRegistry.register(new CursorProvider());
+  providerRegistry.register(new ContinueProvider());
+  providerRegistry.register(new ZedProvider());
+  providerRegistry.register(new OpenCodeProvider());
+  providerRegistry.register(new CodexProvider());
+  providerRegistry.register(new WindsurfProvider());
+  providerRegistry.register(new AntigravityProvider());
+
+  initialized = true;
+}
+
+// biome-ignore lint/performance/noBarrelFile: Intentional barrel for provider initialization
+export { registry } from "./registry.js";
+export type { ConfigFormat, Provider, ProviderMetadata } from "./types.js";

package/src/providers/opencode.ts

@@ -0,0 +1,42 @@
+import { join } from "node:path";
+import type { McpServer } from "../config/schema.js";
+import { BaseProvider } from "./base.js";
+
+export class OpenCodeProvider extends BaseProvider {
+  name = "opencode";
+  configPath = (home: string) =>
+    join(home, ".config", "opencode", "opencode.json");
+  format = "json" as const;
+  mcpKey = "mcp";
+  skillsPath = (home: string) => join(home, ".opencode", "skills");
+
+  transformMcpServers(
+    servers: Record<string, McpServer>
+  ): Record<string, unknown> {
+    const transformed: Record<string, unknown> = {};
+
+    for (const [name, server] of Object.entries(servers)) {
+      if (server.url) {
+        transformed[name] = {
+          type: "remote",
+          url: server.url,
+          ...(server.headers && { headers: server.headers }),
+          enabled: true,
+        };
+      } else if (server.command) {
+        const command = [server.command, ...(server.args || [])];
+
+        transformed[name] = {
+          type: "local",
+          command,
+          ...(server.env && { environment: server.env }),
+          enabled: true,
+        };
+      } else {
+        console.warn(`Skipping server "${name}" - missing command or url`);
+      }
+    }
+
+    return transformed;
+  }
+}

package/src/providers/registry.ts

@@ -0,0 +1,74 @@
+import type { Provider } from "./types.js";
+
+/**
+ * Global provider registry
+ */
+class ProviderRegistry {
+  private readonly providers: Map<string, Provider> = new Map();
+
+  /**
+   * Register a provider
+   */
+  register(provider: Provider): void {
+    this.providers.set(provider.name, provider);
+  }
+
+  /**
+   * Get a provider by name
+   */
+  get(name: string): Provider | undefined {
+    return this.providers.get(name);
+  }
+
+  /**
+   * Get all registered providers (sorted by name for deterministic ordering)
+   */
+  getAll(): Provider[] {
+    return Array.from(this.providers.values()).sort((a, b) =>
+      a.name.localeCompare(b.name)
+    );
+  }
+
+  /**
+   * Get all provider names (sorted for deterministic ordering)
+   */
+  getNames(): string[] {
+    return Array.from(this.providers.keys()).sort();
+  }
+
+  /**
+   * Check if a provider is registered
+   */
+  has(name: string): boolean {
+    return this.providers.has(name);
+  }
+
+  /**
+   * Get all installed providers (sorted by name for deterministic ordering)
+   */
+  async getInstalled(): Promise<Provider[]> {
+    const all = this.getAll();
+    const installed: Provider[] = [];
+
+    for (const provider of all) {
+      if (await provider.isInstalled()) {
+        installed.push(provider);
+      }
+    }
+
+    return installed.sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  /**
+   * Clear all registered providers (mainly for testing)
+   */
+  clear(): void {
+    this.providers.clear();
+  }
+}
+
+// Export singleton instance
+export const registry = new ProviderRegistry();
+
+// Export class for testing
+export { ProviderRegistry };

package/src/providers/types.ts

@@ -0,0 +1,99 @@
+import type { McpServer } from "../config/schema.js";
+
+export type ConfigFormat = "json" | "yaml" | "toml";
+
+export interface StdioServerConfig {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface HttpServerConfig {
+  url: string;
+  headers?: Record<string, string>;
+}
+
+export interface OpenCodeServerConfig {
+  type: "local" | "remote";
+  command?: string[];
+  url?: string;
+  environment?: Record<string, string>;
+  headers?: Record<string, string>;
+  enabled: boolean;
+}
+
+export interface CodexServerConfig {
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  url?: string;
+  http_headers?: Record<string, string>;
+  enabled: boolean;
+  startup_timeout_sec?: number;
+  enabled_tools?: string[];
+}
+
+export interface WindsurfHttpServerConfig extends HttpServerConfig {
+  transport: "streamable-http";
+}
+
+export interface ProviderConfig {
+  [key: string]: unknown;
+}
+
+/**
+ * Provider interface - defines how to interact with each AI coding assistant
+ */
+export interface Provider {
+  /** Provider name (e.g., 'claude-desktop', 'cursor') */
+  name: string;
+
+  /** Path to provider's config file (can be function for dynamic paths) */
+  configPath: string | ((home: string) => string);
+
+  /** Config file format */
+  format: ConfigFormat;
+
+  /** Key in config where MCP servers are stored (e.g., 'mcpServers', 'context_servers') */
+  mcpKey: string;
+
+  /** Optional path to provider's skills directory */
+  skillsPath?: string | ((home: string) => string);
+
+  /**
+   * Check if provider is installed on this system
+   */
+  isInstalled(home?: string): Promise<boolean>;
+
+  /**
+   * Read provider's current config
+   */
+  readConfig(home?: string): Promise<unknown>;
+
+  /**
+   * Write config to provider's config file
+   * Should use atomic write and backup
+   */
+  writeConfig(config: unknown, home?: string): Promise<void>;
+
+  /**
+   * Transform TAAL MCP servers to provider-specific format
+   */
+  transformMcpServers(servers: Record<string, McpServer>): unknown;
+
+  /**
+   * Optional: Transform skills to provider-specific format
+   */
+  transformSkills?(skills: unknown[]): unknown;
+}
+
+/**
+ * Provider metadata for registration
+ */
+export interface ProviderMetadata {
+  name: string;
+  configPath: string | ((home: string) => string);
+  format: ConfigFormat;
+  mcpKey: string;
+  skillsPath?: string | ((home: string) => string);
+}

package/src/providers/utils.ts

@@ -0,0 +1,106 @@
+import { existsSync, readFileSync } from "node:fs";
+import type { JsonMap } from "@iarna/toml";
+import { parse as parseToml, stringify as stringifyToml } from "@iarna/toml";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { atomicWrite } from "../utils/atomic-write.js";
+import { backupConfig } from "../utils/backup.js";
+import type { ConfigFormat } from "./types.js";
+
+/**
+ * Read and parse a JSON config file
+ */
+export function readJsonConfig(path: string): unknown {
+  if (!existsSync(path)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to read JSON config at ${path}: ${error}`);
+  }
+}
+
+/**
+ * Read and parse a YAML config file
+ */
+export function readYamlConfig(path: string): unknown {
+  if (!existsSync(path)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(path, "utf-8");
+    return parseYaml(content);
+  } catch (error) {
+    throw new Error(`Failed to read YAML config at ${path}: ${error}`);
+  }
+}
+
+/**
+ * Read and parse a TOML config file
+ */
+export function readTomlConfig(path: string): unknown {
+  if (!existsSync(path)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(path, "utf-8");
+    return parseToml(content);
+  } catch (error) {
+    throw new Error(`Failed to read TOML config at ${path}: ${error}`);
+  }
+}
+
+/**
+ * Read config file based on format
+ */
+export function readConfig(path: string, format: ConfigFormat): unknown {
+  switch (format) {
+    case "json":
+      return readJsonConfig(path);
+    case "yaml":
+      return readYamlConfig(path);
+    case "toml":
+      return readTomlConfig(path);
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
+  }
+}
+
+export function writeConfig(
+  path: string,
+  format: ConfigFormat,
+  config: unknown
+): void {
+  backupConfig(path);
+
+  let content: string;
+  switch (format) {
+    case "json":
+      content = JSON.stringify(config, null, 2);
+      break;
+    case "yaml":
+      content = stringifyYaml(config);
+      break;
+    case "toml":
+      content = stringifyToml(config as JsonMap);
+      break;
+    default:
+      throw new Error(`Unsupported config format: ${format}`);
+  }
+
+  atomicWrite(path, content);
+}
+
+/**
+ * Resolve config path (handle both string and function)
+ */
+export function resolveConfigPath(
+  configPath: string | ((home: string) => string),
+  home: string
+): string {
+  return typeof configPath === "function" ? configPath(home) : configPath;
+}

package/src/providers/windsurf.ts

@@ -0,0 +1,50 @@
+import { platform } from "node:os";
+import { join } from "node:path";
+import type { McpServer } from "../config/schema.js";
+import { BaseProvider } from "./base.js";
+
+export class WindsurfProvider extends BaseProvider {
+  name = "windsurf";
+  configPath = (home: string) => {
+    const os = platform();
+    if (os === "darwin") {
+      return join(
+        home,
+        "Library",
+        "Application Support",
+        "Windsurf",
+        "User",
+        "settings.json"
+      );
+    }
+    return join(home, ".config", "Windsurf", "User", "settings.json");
+  };
+  format = "json" as const;
+  mcpKey = "mcpServers";
+
+  transformMcpServers(
+    servers: Record<string, McpServer>
+  ): Record<string, unknown> {
+    const transformed: Record<string, unknown> = {};
+
+    for (const [name, server] of Object.entries(servers)) {
+      if (server.url) {
+        transformed[name] = {
+          url: server.url,
+          transport: "streamable-http",
+          ...(server.headers && { headers: server.headers }),
+        };
+      } else if (server.command) {
+        transformed[name] = {
+          command: server.command,
+          ...(server.args && { args: server.args }),
+          ...(server.env && { env: server.env }),
+        };
+      } else {
+        console.warn(`Skipping server "${name}" - missing command or url`);
+      }
+    }
+
+    return transformed;
+  }
+}

package/src/providers/zed.ts

@@ -0,0 +1,35 @@
+import { join } from "node:path";
+import type { McpServer } from "../config/schema.js";
+import { BaseProvider } from "./base.js";
+
+export class ZedProvider extends BaseProvider {
+  name = "zed";
+  configPath = (home: string) => join(home, ".config", "zed", "settings.json");
+  format = "json" as const;
+  mcpKey = "context_servers";
+
+  transformMcpServers(
+    servers: Record<string, McpServer>
+  ): Record<string, unknown> {
+    const transformed: Record<string, unknown> = {};
+
+    for (const [name, server] of Object.entries(servers)) {
+      if (server.url) {
+        transformed[name] = {
+          url: server.url,
+          ...(server.headers && { headers: server.headers }),
+        };
+      } else if (server.command) {
+        transformed[name] = {
+          command: server.command,
+          ...(server.args && { args: server.args }),
+          ...(server.env && { env: server.env }),
+        };
+      } else {
+        console.warn(`Skipping server "${name}" - missing command or url`);
+      }
+    }
+
+    return transformed;
+  }
+}

package/src/scripts/generate-schema.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env bun
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { TaalConfigSchema } from "../config/schema.js";
+
+// Generate JSON Schema from Zod schema
+const jsonSchema = zodToJsonSchema(TaalConfigSchema, {
+  name: "TaalConfig",
+  $refStrategy: "none", // Inline all definitions for simplicity
+});
+
+// Write to root directory
+const schemaPath = join(process.cwd(), "taal.schema.json");
+writeFileSync(schemaPath, JSON.stringify(jsonSchema, null, 2));
+
+console.log(`✓ Generated JSON Schema at ${schemaPath}`);

package/src/skills/copy.ts

@@ -0,0 +1,58 @@
+import { cpSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { basename, join } from "node:path";
+import type { Skill } from "./discovery.js";
+
+/**
+ * Copy skills to a provider's skills directory
+ *
+ * @param skills - Array of skills to copy
+ * @param targetPath - Target directory path (provider's skills directory)
+ * @param options - Copy options
+ */
+export function copySkillsToProvider(
+  skills: Skill[],
+  targetPath: string,
+  options: { overwrite?: boolean } = {}
+): void {
+  const { overwrite = true } = options;
+
+  // Create target directory if it doesn't exist
+  mkdirSync(targetPath, { recursive: true });
+
+  for (const skill of skills) {
+    const skillDirName = basename(skill.path);
+    const targetSkillPath = join(targetPath, skillDirName);
+
+    try {
+      // Remove existing skill if overwrite is enabled
+      if (overwrite && existsSync(targetSkillPath)) {
+        rmSync(targetSkillPath, { recursive: true, force: true });
+      }
+
+      // Copy skill directory recursively
+      cpSync(skill.path, targetSkillPath, {
+        recursive: true,
+        force: overwrite,
+      });
+
+      console.log(`Copied skill "${skill.name}" to ${targetSkillPath}`);
+    } catch (error) {
+      console.warn(`Failed to copy skill "${skill.name}": ${error}`);
+    }
+  }
+}
+
+/**
+ * Copy a single skill to a target directory
+ *
+ * @param skill - Skill to copy
+ * @param targetPath - Target directory path
+ * @param options - Copy options
+ */
+export function copySkill(
+  skill: Skill,
+  targetPath: string,
+  options: { overwrite?: boolean } = {}
+): void {
+  copySkillsToProvider([skill], targetPath, options);
+}