opencode-architect 0.2.0

package/index.ts

@@ -0,0 +1,120 @@
+import type { Plugin, PluginInput } from "@opencode-ai/plugin";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import type { AgentConfig } from "@opencode-ai/sdk";
+import { command as syncDocsCommand } from "./commands/sync-docs";
+import { OpenCodeDocsFetcher } from "./scripts/fetch-opencode-docs";
+import { SilentLogger } from "./scripts/logger";
+import { createSyncDocsTool } from "./tools/sync-docs";
+
+const AGENTS_DIR = path.join(import.meta.dirname, "assets", "agents");
+
+const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+
+interface AgentFrontmatter {
+  description: string;
+  mode: "primary" | "subagent" | "all";
+  tools?: Record<string, boolean>;
+  permission?: {
+    edit?: "ask" | "allow" | "deny";
+    bash?: ("ask" | "allow" | "deny") | Record<string, "ask" | "allow" | "deny">;
+    webfetch?: "ask" | "allow" | "deny";
+    doom_loop?: "ask" | "allow" | "deny";
+    external_directory?: "ask" | "allow" | "deny";
+  };
+}
+
+async function parseAgentMarkdown(content: string, agentName: string): Promise<AgentConfig> {
+  const match = content.match(FRONTMATTER_REGEX);
+
+  if (!match || match.length < 3) {
+    throw new Error(`Agent ${agentName} must have YAML frontmatter`);
+  }
+
+  const frontmatterYaml = match[1] as string;
+  const rawPrompt = match[2] as string;
+  const frontmatter = parseYaml(frontmatterYaml) as AgentFrontmatter;
+  const prompt = rawPrompt.replace(/^\r?\n/, "");
+
+  const config: AgentConfig = {
+    description: frontmatter.description,
+    mode: frontmatter.mode,
+    prompt,
+  };
+
+  if (frontmatter.tools) {
+    config.tools = frontmatter.tools;
+  }
+
+  if (frontmatter.permission) {
+    config.permission = frontmatter.permission;
+  }
+
+  return config;
+}
+
+const OpencodeArchitect: Plugin = async (input) => {
+  const syncDocsTool = createSyncDocsTool();
+
+  syncDocsOnStartup(input.client);
+
+  const agents = await loadAgents();
+
+  return {
+    config: async (config) => {
+      config.agent = config.agent || {};
+      config.command = config.command || {};
+
+      for (const [name, agentConfig] of Object.entries(agents)) {
+        config.agent[name] = agentConfig;
+      }
+
+      config.command["sync-docs"] = syncDocsCommand;
+    },
+    tool: {
+      "sync-docs": syncDocsTool,
+    },
+  };
+};
+
+export default OpencodeArchitect;
+
+async function loadAgents(): Promise<Record<string, AgentConfig>> {
+  const agentFiles = [
+    "opencode-agent-designer.md",
+    "opencode-architect.md",
+    "opencode-command-crafter.md",
+    "opencode-extension-auditor.md",
+    "opencode-packager.md",
+    "opencode-publisher.md",
+    "opencode-mcp-integrator.md",
+    "opencode-plugin-engineer.md",
+    "opencode-skill-creator.md",
+    "opencode-tool-builder.md",
+  ];
+
+  const agents: Record<string, AgentConfig> = {};
+
+  for (const filename of agentFiles) {
+    const agentPath = path.join(AGENTS_DIR, filename);
+    const agentContent = await readFile(agentPath, "utf-8");
+    const agentName = path.basename(filename, ".md");
+    agents[agentName] = await parseAgentMarkdown(agentContent, agentName);
+  }
+
+  return agents;
+}
+
+function syncDocsOnStartup(client: PluginInput["client"]): void {
+  const fetcher = new OpenCodeDocsFetcher(new SilentLogger());
+  fetcher.run().catch((error: unknown) => {
+    const message = error instanceof Error ? error.message : String(error);
+    client.tui.showToast({
+      body: {
+        message: `Failed to sync OpenCode docs: ${message}`,
+        variant: "error",
+      },
+    });
+  });
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "opencode-architect",
+  "version": "0.2.0",
+  "private": false,
+  "type": "module",
+  "module": "index.ts",
+  "scripts": {
+    "check": "tsc --noEmit",
+    "release": "npm version patch && npm publish && git push --follow-tags"
+  },
+  "exports": {
+    ".": {
+      "import": "./index.ts"
+    }
+  },
+  "files": [
+    "index.ts",
+    "tools",
+    "commands",
+    "scripts",
+    "assets"
+  ],
+  
+  "dependencies": {
+    "yaml": "^2.7.1"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "latest",
+    "@opencode-ai/sdk": "latest",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/scripts/fetch-opencode-docs.ts

@@ -0,0 +1,193 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import type { Logger } from "./logger";
+import { ConsoleLogger } from "./logger";
+
+interface ExternalDoc {
+  url: string;
+  filename: string;
+}
+
+export class OpenCodeDocsFetcher {
+  private readonly sitemapUrl: string;
+  private readonly docsDir: string;
+  private readonly externalDocs: ExternalDoc[];
+  private readonly logger: Logger;
+
+  public constructor(logger: Logger | null = null) {
+    this.sitemapUrl = "https://opencode.ai/sitemap.xml";
+    this.docsDir = path.join(
+      os.homedir(),
+      ".cache",
+      "opencode",
+      "opencode-architect",
+      "docs",
+    );
+    this.logger = logger ?? new ConsoleLogger();
+    this.externalDocs = [
+      {
+        url: "https://platform.claude.com/docs/en/agents-and-tools/agent-skills/best-practices.md",
+        filename: "claude-skill-best-practices.md",
+      },
+      {
+        url: "https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-4-best-practices.md",
+        filename: "claude-4-best-practices.md",
+      },
+    ];
+  }
+
+  public async run(): Promise<void> {
+    try {
+      await this.ensureDocsDir();
+      const sitemap = await this.fetchText(this.sitemapUrl);
+      const docUrls = this.extractDocUrls(sitemap);
+      const markdownUrls = this.buildMarkdownUrls(docUrls);
+      await this.downloadDocs(markdownUrls);
+      await this.downloadExternalDocs();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to fetch OpenCode docs: ${message}`);
+      process.exitCode = 1;
+    }
+  }
+
+  private async ensureDocsDir(): Promise<void> {
+    await mkdir(this.docsDir, { recursive: true });
+  }
+
+  private async fetchText(url: string): Promise<string> {
+    const response = await fetch(url, {
+      headers: {
+        "User-Agent": "opencode-docs-fetcher",
+      },
+    });
+    if (!response.ok) {
+      throw new Error(`Request failed (${response.status}) for ${url}`);
+    }
+    return await response.text();
+  }
+
+  private extractDocUrls(sitemap: string): string[] {
+    const urls: string[] = [];
+    const regex = /<loc>([^<]+)<\/loc>/g;
+    let match: RegExpExecArray | null = regex.exec(sitemap);
+    while (match) {
+      const url = match[1];
+      if (url !== undefined) {
+        try {
+          const parsed = new URL(url);
+          if (parsed.pathname.startsWith("/docs/")) {
+            urls.push(url);
+          }
+        } catch {
+          continue;
+        }
+      }
+      match = regex.exec(sitemap);
+    }
+    return Array.from(new Set(urls));
+  }
+
+  private buildMarkdownUrls(urls: string[]): string[] {
+    const markdownUrls: string[] = [];
+    for (const url of urls) {
+      const parsed = new URL(url);
+      if (!parsed.pathname.startsWith("/docs/")) {
+        continue;
+      }
+      const normalizedPath = this.normalizeDocPath(parsed.pathname);
+      if (normalizedPath === "/docs") {
+        continue;
+      }
+      const markdownUrl = `${parsed.origin}${normalizedPath}.md`;
+      markdownUrls.push(markdownUrl);
+    }
+    return Array.from(new Set(markdownUrls));
+  }
+
+  private normalizeDocPath(pathname: string): string {
+    if (pathname.endsWith("/")) {
+      return pathname.slice(0, -1);
+    }
+    return pathname;
+  }
+
+  private async downloadDocs(urls: string[]): Promise<void> {
+    let successCount = 0;
+    let failureCount = 0;
+    for (const url of urls) {
+      try {
+        const content = await this.fetchText(url);
+        const filename = this.buildFilename(url);
+        const filePath = path.join(this.docsDir, filename);
+        await writeFile(filePath, content);
+        successCount += 1;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Failed to fetch ${url}: ${message}`);
+        failureCount += 1;
+      }
+    }
+
+    this.logger.info(
+      `OpenCode docs fetch complete. Success: ${successCount}, Failed: ${failureCount}.`,
+    );
+  }
+
+  private async downloadExternalDocs(): Promise<void> {
+    let successCount = 0;
+    let failureCount = 0;
+    for (const doc of this.externalDocs) {
+      try {
+        const content = await this.fetchText(doc.url);
+        const filePath = path.join(this.docsDir, doc.filename);
+        await writeFile(filePath, content);
+        successCount += 1;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.error(`Failed to fetch ${doc.url}: ${message}`);
+        failureCount += 1;
+      }
+    }
+
+    this.logger.info(
+      `External docs fetch complete. Success: ${successCount}, Failed: ${failureCount}.`,
+    );
+  }
+
+  private buildFilename(url: string): string {
+    const parsed = new URL(url);
+    const pathname = parsed.pathname;
+    if (pathname === "/docs.md" || pathname === "/docs/.md") {
+      return "index.md";
+    }
+
+    let relative = pathname;
+    if (relative.startsWith("/docs/")) {
+      relative = relative.slice("/docs/".length);
+    } else if (relative.startsWith("/docs")) {
+      relative = relative.slice("/docs".length);
+    }
+
+    if (relative.startsWith("/")) {
+      relative = relative.slice(1);
+    }
+
+    if (relative.length === 0) {
+      return "index.md";
+    }
+
+    const normalized = relative.replace(/\//g, "-");
+    if (normalized.endsWith(".md")) {
+      return normalized;
+    }
+    return `${normalized}.md`;
+  }
+
+}
+
+if (import.meta.main) {
+  void new OpenCodeDocsFetcher().run();
+}

package/scripts/logger.ts

@@ -0,0 +1,20 @@
+export interface Logger {
+  info(message: string): void;
+  error(message: string): void;
+}
+
+export class ConsoleLogger implements Logger {
+  public info(message: string): void {
+    console.log(message);
+  }
+
+  public error(message: string): void {
+    console.error(message);
+  }
+}
+
+export class SilentLogger implements Logger {
+  public info(_message: string): void {}
+
+  public error(_message: string): void {}
+}

package/tools/sync-docs.ts

@@ -0,0 +1,24 @@
+import { tool } from "@opencode-ai/plugin";
+
+import { OpenCodeDocsFetcher } from "../scripts/fetch-opencode-docs";
+
+type ToolDefinition = ReturnType<typeof tool>;
+
+function createSyncDocsTool(): ToolDefinition {
+  return tool({
+    description: "Sync OpenCode documentation by fetching the latest docs from opencode.ai",
+    args: {},
+    async execute(_args, _context) {
+      try {
+        const fetcher = new OpenCodeDocsFetcher();
+        await fetcher.run();
+        return "Successfully synced OpenCode documentation.";
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return `Failed to sync docs: ${message}`;
+      }
+    },
+  });
+}
+
+export { createSyncDocsTool };