@encoredigitalgroup/opencode 0.1.0

package/LICENSE.md

@@ -0,0 +1 @@
+See [documentation site](https://docs.encoredigitalgroup.com/license)

package/README.md

@@ -0,0 +1,56 @@
+# OpenCode planning commands
+
+`@encoredigitalgroup/opencode` adds file pickers for OpenCode planning commands.
+
+The TUI provides `/plan-review`, `/plan-split`, and `/plan-execute` commands. Each command opens a picker for plans in `docs/_planning` and inserts the selected plan
+into the prompt. The server entry expands the selected plan into the matching installed skill prompt.
+
+## Install
+
+Add the package to the `plugin` array in your OpenCode configuration:
+
+- Use `~/.config/opencode/opencode.json` to enable it for every project.
+- Use `opencode.json` in a project to enable it only there.
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": ["@encoredigitalgroup/opencode"]
+}
+```
+
+Restart OpenCode after changing the configuration. OpenCode downloads missing npm plugins that appear in the `plugin` array, so you do not need to install this package
+with Bun or npm yourself.
+
+The plugin resolves the mapped skills through OpenCode, so those skills can live in any location that OpenCode discovers.
+
+## Configuration
+
+Pass options as the second item in the `plugin` entry. `planDirectory` is relative to the workspace. `skillMappings` can override any plugin command's installed skill name.
+Unspecified values use the defaults: `docs/_planning` and the command's existing skill name.
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugin": [
+    [
+      "@encoredigitalgroup/opencode",
+      {
+        "planDirectory": "plans",
+        "skillMappings": {
+          "plan-review": "custom-plan-review",
+          "plan-execute": "custom-plan-execute"
+        }
+      }
+    ]
+  ]
+}
+```
+
+## Development
+
+```sh
+bun install
+bun run check
+bun run pack:check
+```

package/dist/config/ConfigDefaults.d.ts

@@ -0,0 +1,8 @@
+import type { PluginConfig, SkillMappings } from "./ConfigTypes.js";
+/** Provides default configuration values for the plugin. */
+export declare class ConfigDefaults {
+    /** Get the default skill mappings. */
+    static getDefaultSkillMappings(): SkillMappings;
+    /** Get the complete default configuration. */
+    static getDefaultConfig(): PluginConfig;
+}

package/dist/config/ConfigLoader.d.ts

@@ -0,0 +1,13 @@
+import type { PluginOptions } from "@opencode-ai/plugin";
+import { type PluginConfig } from "./ConfigTypes.js";
+/** Loads plugin settings from the OpenCode plugin options. */
+export declare class ConfigLoader {
+    private static stringOption;
+    private static planDirectoryOption;
+    /** Get valid skill mappings from plugin options. */
+    private static skillMappingsOption;
+    /** Get the configured option values that can override the defaults. */
+    private static getUserConfig;
+    /** Merge configured plugin options with the defaults. */
+    static loadConfig(options: PluginOptions | undefined): PluginConfig;
+}

package/dist/config/ConfigMerger.d.ts

@@ -0,0 +1,6 @@
+import { type PluginConfig, type UserPluginConfig } from "./ConfigTypes.js";
+/** Merges user configuration with the default configuration. */
+export declare class ConfigMerger {
+    /** Merge user configuration with the defaults. */
+    static merge(userConfig: UserPluginConfig): PluginConfig;
+}

package/dist/config/ConfigTypes.d.ts

@@ -0,0 +1,16 @@
+export declare const skillCommands: readonly ["feature-planning", "plan-execute", "plan-resync", "plan-review", "plan-split"];
+export type SkillCommand = (typeof skillCommands)[number];
+export type SkillMappings = Record<SkillCommand, string>;
+export type PluginConfig = {
+    planDirectory: string;
+    skillMappings: SkillMappings;
+};
+export type UserPluginConfig = {
+    planDirectory?: string;
+    skillMappings?: Partial<SkillMappings>;
+};
+/** Configuration type utilities. */
+export declare class ConfigTypes {
+    /** Get all commands with configurable skill mappings. */
+    static getSkillCommands(): SkillCommand[];
+}

package/dist/config/ConfigValidator.d.ts

@@ -0,0 +1,13 @@
+import { type PluginConfig } from "./ConfigTypes.js";
+/** Validation result containing configuration errors. */
+export type ValidationResult = {
+    errors: string[];
+    valid: boolean;
+};
+/** Validates plugin configuration objects. */
+export declare class ConfigValidator {
+    /** Validate a configuration object. */
+    static validate(config: PluginConfig): ValidationResult;
+    /** Validate a configuration object and throw when it is invalid. */
+    static validateOrThrow(config: PluginConfig): void;
+}

package/dist/config/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./ConfigDefaults.js";
+export * from "./ConfigLoader.js";
+export * from "./ConfigMerger.js";
+export * from "./ConfigTypes.js";
+export * from "./ConfigValidator.js";

package/dist/lib/FilePickerCommands.d.ts

@@ -0,0 +1,36 @@
+import type { TuiPluginApi, TuiPromptRef } from "@opencode-ai/plugin/tui";
+import type { PluginConfig } from "../config";
+export type FilePickerOption = {
+    argument: string;
+    filePath: string;
+    label: string;
+};
+export type FilePickerCommand = {
+    argumentPlaceholder: string;
+    command: string;
+    description: string;
+    emptyMessage: string;
+    excludesPlanningDirectory?(directory: string): boolean;
+    matchesSelection(argument: string, filePath: string): boolean;
+    options(root: string, excludesPlanningDirectory?: (directory: string) => boolean): FilePickerOption[];
+    retainsSelectedFileInPrompt: boolean;
+    skill: string;
+    title: string;
+};
+export declare class FilePickerCommands {
+    private static isPlanPath;
+    private static planOptions;
+    private static hasSubPlans;
+    private static isSubPlanSelection;
+    private static subPlanOptions;
+    static getCommands(config: PluginConfig): readonly FilePickerCommand[];
+    private static findSkill;
+    private static removeSelectedFile;
+    private static expandedSkill;
+    static expand(output: {
+        parts: unknown[];
+    }, template: (skill: string) => Promise<string>, config: PluginConfig): Promise<void>;
+    private static workspaceRoot;
+    private static setPrompt;
+    static register(api: TuiPluginApi, prompt: () => TuiPromptRef | undefined, config: PluginConfig): void;
+}

package/dist/lib/SkillCommands.d.ts

@@ -0,0 +1,15 @@
+import type { PluginConfig } from "../config";
+export declare class SkillCommands {
+    static getCommands(config: PluginConfig): {
+        "feature-planning": {
+            description: string;
+            skill: string;
+        };
+        "plan-resync": {
+            description: string;
+            skill: string;
+        };
+    };
+    private static isSkill;
+    static getTemplate(serverUrl: URL, directory: string, skillName: string): Promise<string>;
+}

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+import type { PluginModule } from "@opencode-ai/plugin";
+declare const plugin: PluginModule;
+export default plugin;

package/dist/server/index.js

@@ -0,0 +1,448 @@
+// @bun
+// src/config/ConfigDefaults.ts
+class ConfigDefaults {
+  static getDefaultSkillMappings() {
+    return {
+      "feature-planning": "feature-planning",
+      "plan-execute": "plan-execute",
+      "plan-resync": "plan-resync",
+      "plan-review": "plan-review",
+      "plan-split": "plan-split"
+    };
+  }
+  static getDefaultConfig() {
+    return {
+      planDirectory: "docs/_planning",
+      skillMappings: this.getDefaultSkillMappings()
+    };
+  }
+}
+// src/config/ConfigTypes.ts
+var skillCommands = [
+  "feature-planning",
+  "plan-execute",
+  "plan-resync",
+  "plan-review",
+  "plan-split"
+];
+
+class ConfigTypes {
+  static getSkillCommands() {
+    return [...skillCommands];
+  }
+}
+
+// src/config/ConfigMerger.ts
+class ConfigMerger {
+  static merge(userConfig) {
+    const config = ConfigDefaults.getDefaultConfig();
+    if (userConfig.planDirectory !== undefined) {
+      config.planDirectory = userConfig.planDirectory;
+    }
+    if (userConfig.skillMappings !== undefined) {
+      for (const command of ConfigTypes.getSkillCommands()) {
+        config.skillMappings[command] = userConfig.skillMappings[command] ?? config.skillMappings[command];
+      }
+    }
+    return config;
+  }
+}
+
+// src/config/ConfigValidator.ts
+class ConfigValidator {
+  static validate(config) {
+    const errors = [];
+    if (config.planDirectory.trim() === "") {
+      errors.push("Invalid planDirectory: must be a non-empty string.");
+    }
+    for (const command of ConfigTypes.getSkillCommands()) {
+      if (config.skillMappings[command].trim() === "") {
+        errors.push(`Invalid skillMappings.${command}: must be a non-empty string.`);
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  static validateOrThrow(config) {
+    const result = this.validate(config);
+    if (!result.valid) {
+      throw new Error(`Invalid configuration:
+${result.errors.join(`
+`)}`);
+    }
+  }
+}
+
+// src/config/ConfigLoader.ts
+class ConfigLoader {
+  static stringOption(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+  }
+  static planDirectoryOption(value) {
+    const directory = this.stringOption(value)?.replace(/\/+$/, "");
+    return directory === "" ? undefined : directory;
+  }
+  static skillMappingsOption(value) {
+    if (typeof value !== "object" || value === null) {
+      return;
+    }
+    const mappingOptions = value;
+    const skillMappings = {};
+    for (const command of ConfigTypes.getSkillCommands()) {
+      const skill = this.stringOption(mappingOptions[command]);
+      if (skill !== undefined) {
+        skillMappings[command] = skill;
+      }
+    }
+    return skillMappings;
+  }
+  static getUserConfig(options) {
+    const planDirectory = this.planDirectoryOption(options?.planDirectory);
+    const skillMappings = this.skillMappingsOption(options?.skillMappings);
+    return {
+      ...planDirectory === undefined ? {} : { planDirectory },
+      ...skillMappings === undefined ? {} : { skillMappings }
+    };
+  }
+  static loadConfig(options) {
+    try {
+      const config = ConfigMerger.merge(this.getUserConfig(options));
+      ConfigValidator.validateOrThrow(config);
+      return config;
+    } catch {
+      return ConfigDefaults.getDefaultConfig();
+    }
+  }
+}
+// src/lib/FilePickerCommands.ts
+import { createComponent } from "@opentui/solid";
+import { readdirSync, statSync } from "fs";
+import { join, resolve } from "path";
+import { pathToFileURL } from "url";
+
+class FilePickerCommands {
+  static isPlanPath(path, planDirectory) {
+    return path.startsWith(`${planDirectory}/`) && path.endsWith("/plan.md") && !path.slice(planDirectory.length + 1, -"/plan.md".length).includes("/") && !/\s/.test(path.slice(planDirectory.length + 1, -"/plan.md".length));
+  }
+  static planOptions(root, planDirectory, excludesPlanningDirectory = () => false) {
+    const planningDirectory = join(root, planDirectory);
+    try {
+      return readdirSync(planningDirectory, { withFileTypes: true }).filter((entry) => {
+        if (!entry.isDirectory()) {
+          return false;
+        }
+        if (excludesPlanningDirectory(join(planningDirectory, entry.name))) {
+          return false;
+        }
+        try {
+          return statSync(join(planningDirectory, entry.name, "plan.md")).isFile();
+        } catch {
+          return false;
+        }
+      }).map((entry) => ({
+        argument: `${planDirectory}/${entry.name}/plan.md`,
+        filePath: `${planDirectory}/${entry.name}/plan.md`,
+        label: entry.name
+      })).sort((left, right) => left.label.localeCompare(right.label));
+    } catch {
+      return [];
+    }
+  }
+  static hasSubPlans(directory) {
+    try {
+      return readdirSync(directory, { withFileTypes: true }).some((entry) => entry.isFile() && /^\d{2}-.+\.md$/.test(entry.name));
+    } catch {
+      return false;
+    }
+  }
+  static isSubPlanSelection(argument, filePath, planDirectory) {
+    return argument.startsWith(`${planDirectory}/`) && !argument.slice(planDirectory.length + 1).includes("/") && !/\s/.test(argument.slice(planDirectory.length + 1)) && filePath.startsWith(`${argument}/`) && filePath !== `${argument}/plan.md` && filePath.endsWith(".md");
+  }
+  static subPlanOptions(root, planDirectory) {
+    const planningDirectory = join(root, planDirectory);
+    try {
+      return readdirSync(planningDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+        const directory = join(planningDirectory, entry.name);
+        try {
+          const subPlan = readdirSync(directory, { withFileTypes: true }).filter((file) => file.isFile() && file.name !== "plan.md" && file.name.endsWith(".md")).map((file) => file.name).sort((left, right) => left.localeCompare(right))[0];
+          return subPlan === undefined ? [] : [{
+            argument: `${planDirectory}/${entry.name}`,
+            filePath: `${planDirectory}/${entry.name}/${subPlan}`,
+            label: entry.name
+          }];
+        } catch {
+          return [];
+        }
+      }).sort((left, right) => left.label.localeCompare(right.label));
+    } catch {
+      return [];
+    }
+  }
+  static getCommands(config) {
+    const { planDirectory, skillMappings } = config;
+    const noPlansMessage = `No plan.md files found in ${planDirectory}.`;
+    const noSubPlansMessage = `No sub-plan files found in ${planDirectory}.`;
+    return [
+      {
+        argumentPlaceholder: "$ARGUMENTS",
+        command: "plan-review",
+        description: "Select a plan to review",
+        emptyMessage: noPlansMessage,
+        matchesSelection: (argument, filePath) => argument === filePath && FilePickerCommands.isPlanPath(argument, planDirectory),
+        options: (root, excludesPlanningDirectory) => FilePickerCommands.planOptions(root, planDirectory, excludesPlanningDirectory),
+        retainsSelectedFileInPrompt: true,
+        skill: skillMappings["plan-review"],
+        title: "Select a plan to review"
+      },
+      {
+        argumentPlaceholder: "$ARGUMENTS",
+        command: "plan-split",
+        description: "Select a plan to split",
+        emptyMessage: noPlansMessage,
+        excludesPlanningDirectory: FilePickerCommands.hasSubPlans,
+        matchesSelection: (argument, filePath) => argument === filePath && FilePickerCommands.isPlanPath(argument, planDirectory),
+        options: (root, excludesPlanningDirectory) => FilePickerCommands.planOptions(root, planDirectory, excludesPlanningDirectory),
+        retainsSelectedFileInPrompt: true,
+        skill: skillMappings["plan-split"],
+        title: "Select a plan to split"
+      },
+      {
+        argumentPlaceholder: "$PLAN_DIR",
+        command: "plan-execute",
+        description: "Select sub-plans to execute",
+        emptyMessage: noSubPlansMessage,
+        matchesSelection: (argument, filePath) => FilePickerCommands.isSubPlanSelection(argument, filePath, planDirectory),
+        options: (root) => FilePickerCommands.subPlanOptions(root, planDirectory),
+        retainsSelectedFileInPrompt: false,
+        skill: skillMappings["plan-execute"],
+        title: "Select sub-plans to execute"
+      }
+    ];
+  }
+  static findSkill(text, parts, config) {
+    const filePaths = parts.flatMap((part) => {
+      if (typeof part !== "object" || part === null || !("type" in part) || part.type !== "file" || !("source" in part)) {
+        return [];
+      }
+      const { source } = part;
+      return typeof source === "object" && source !== null && "type" in source && source.type === "file" && "path" in source && typeof source.path === "string" ? [source.path] : [];
+    });
+    for (const command of FilePickerCommands.getCommands(config)) {
+      const prefix = `/${command.command} @`;
+      if (!text.startsWith(prefix)) {
+        continue;
+      }
+      const argument = text.slice(prefix.length).trim();
+      const filePath = filePaths.find((path) => command.matchesSelection(argument, path));
+      if (argument !== "" && filePath !== undefined) {
+        return {
+          argument,
+          argumentPlaceholder: command.argumentPlaceholder,
+          filePath,
+          retainsSelectedFileInPrompt: command.retainsSelectedFileInPrompt,
+          skill: command.skill
+        };
+      }
+    }
+  }
+  static removeSelectedFile(parts, filePath) {
+    const selectedFileIndex = parts.findIndex((candidate) => {
+      if (typeof candidate !== "object" || candidate === null || !("type" in candidate) || candidate.type !== "file" || !("source" in candidate)) {
+        return false;
+      }
+      const { source } = candidate;
+      return typeof source === "object" && source !== null && "type" in source && source.type === "file" && "path" in source && source.path === filePath;
+    });
+    if (selectedFileIndex !== -1) {
+      parts.splice(selectedFileIndex, 1);
+    }
+  }
+  static expandedSkill(text, parts, commands) {
+    for (const part of parts) {
+      if (typeof part !== "object" || part === null || !("type" in part) || part.type !== "file" || !("source" in part)) {
+        continue;
+      }
+      const { source } = part;
+      if (typeof source !== "object" || source === null || !("type" in source) || source.type !== "file" || !("path" in source) || !("text" in source)) {
+        continue;
+      }
+      const filePath = source.path;
+      if (typeof filePath !== "string" || typeof source.text !== "object" || source.text === null || !("value" in source.text) || typeof source.text.value !== "string" || !source.text.value.startsWith("@")) {
+        continue;
+      }
+      const argument = source.text.value.slice(1);
+      const command = commands.find((candidate) => candidate.matchesSelection(argument, filePath) && text.includes(candidate.argumentPlaceholder));
+      if (command !== undefined) {
+        return {
+          argument,
+          argumentPlaceholder: command.argumentPlaceholder,
+          filePath,
+          retainsSelectedFileInPrompt: command.retainsSelectedFileInPrompt,
+          skill: command.skill
+        };
+      }
+    }
+  }
+  static async expand(output, template, config) {
+    const commands = FilePickerCommands.getCommands(config);
+    for (const part of output.parts) {
+      if (typeof part !== "object" || part === null || !("type" in part) || part.type !== "text" || !("text" in part) || typeof part.text !== "string" || "synthetic" in part && part.synthetic) {
+        continue;
+      }
+      const skill = FilePickerCommands.findSkill(part.text, output.parts, config);
+      if (skill === undefined) {
+        continue;
+      }
+      part.text = (await template(skill.skill)).replaceAll(skill.argumentPlaceholder, `@${skill.argument}`).trim();
+      if (!skill.retainsSelectedFileInPrompt) {
+        FilePickerCommands.removeSelectedFile(output.parts, skill.filePath);
+      }
+      return;
+    }
+    for (const part of output.parts) {
+      if (typeof part !== "object" || part === null || !("type" in part) || part.type !== "text" || !("text" in part) || typeof part.text !== "string" || "synthetic" in part && part.synthetic) {
+        continue;
+      }
+      const skill = FilePickerCommands.expandedSkill(part.text, output.parts, commands);
+      if (skill === undefined) {
+        continue;
+      }
+      part.text = part.text.replaceAll(skill.argumentPlaceholder, `@${skill.argument}`);
+      if (!skill.retainsSelectedFileInPrompt) {
+        FilePickerCommands.removeSelectedFile(output.parts, skill.filePath);
+      }
+      return;
+    }
+  }
+  static workspaceRoot(worktree, directory) {
+    return worktree === "/" ? directory : worktree;
+  }
+  static setPrompt(prompt, root, command, option) {
+    const mention = `@${option.argument}`;
+    const input = `/${command.command} ${mention} `;
+    const start = Bun.stringWidth(`/${command.command} `);
+    prompt.set({
+      input,
+      mode: "normal",
+      parts: [
+        {
+          type: "file",
+          mime: "text/plain",
+          filename: option.filePath,
+          url: pathToFileURL(resolve(root, option.filePath)).href,
+          source: {
+            type: "file",
+            path: option.filePath,
+            text: {
+              start,
+              end: start + Bun.stringWidth(mention),
+              value: mention
+            }
+          }
+        }
+      ]
+    });
+    prompt.focus();
+  }
+  static register(api, prompt, config) {
+    api.keymap.registerLayer({
+      commands: FilePickerCommands.getCommands(config).map((command) => ({
+        name: `encoredigitalgroup-opencode.${command.command}`,
+        title: command.title,
+        category: "Plugin",
+        namespace: "palette",
+        slashName: command.command,
+        run() {
+          const root = FilePickerCommands.workspaceRoot(api.state.path.worktree, api.state.path.directory);
+          const options = command.options(root, command.excludesPlanningDirectory);
+          if (options.length === 0) {
+            api.ui.toast({
+              variant: "warning",
+              message: command.emptyMessage
+            });
+            return;
+          }
+          const DialogSelect = api.ui.DialogSelect;
+          api.ui.dialog.setSize("medium");
+          api.ui.dialog.replace(() => createComponent(DialogSelect, {
+            title: command.title,
+            options: options.map((option) => ({ title: option.label, value: option })),
+            onSelect: (option) => {
+              api.ui.dialog.clear();
+              const promptRef = prompt();
+              if (promptRef === undefined) {
+                api.ui.toast({
+                  variant: "error",
+                  message: "The prompt is not ready."
+                });
+                return;
+              }
+              FilePickerCommands.setPrompt(promptRef, root, command, option.value);
+            }
+          }));
+        }
+      }))
+    });
+  }
+}
+
+// src/lib/SkillCommands.ts
+import { readFile } from "fs/promises";
+
+class SkillCommands {
+  static getCommands(config) {
+    return {
+      "feature-planning": {
+        description: "Create a feature implementation plan.",
+        skill: config.skillMappings["feature-planning"]
+      },
+      "plan-resync": {
+        description: "Reconcile an implementation plan with the current codebase.",
+        skill: config.skillMappings["plan-resync"]
+      }
+    };
+  }
+  static isSkill(value) {
+    return typeof value === "object" && value !== null && "location" in value && typeof value.location === "string" && "name" in value && typeof value.name === "string";
+  }
+  static async getTemplate(serverUrl, directory, skillName) {
+    const url = new URL("/api/skill", serverUrl);
+    url.searchParams.set("directory", directory);
+    url.searchParams.set("location[directory]", directory);
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Unable to list OpenCode skills: ${response.status} ${response.statusText}`);
+    }
+    const responseBody = await response.json();
+    const skills = typeof responseBody === "object" && responseBody !== null && "data" in responseBody && Array.isArray(responseBody.data) ? responseBody.data.filter(SkillCommands.isSkill) : [];
+    const skill = skills.find((candidate) => candidate.name === skillName);
+    if (skill === undefined) {
+      throw new Error(`OpenCode skill "${skillName}" is not available.`);
+    }
+    return readFile(skill.location, "utf8");
+  }
+}
+
+// src/server/index.ts
+var plugin = {
+  id: "encoredigitalgroup-opencode",
+  server: async (input, options) => {
+    const pluginConfig = ConfigLoader.loadConfig(options);
+    const template = (skill) => SkillCommands.getTemplate(input.serverUrl, input.directory, skill);
+    return {
+      config: async (config) => {
+        config.command ??= {};
+        for (const [command, route] of Object.entries(SkillCommands.getCommands(pluginConfig))) {
+          config.command[command] = {
+            description: route.description,
+            template: await template(route.skill)
+          };
+        }
+      },
+      "chat.message": async (_input, output) => FilePickerCommands.expand(output, template, pluginConfig)
+    };
+  }
+};
+var server_default = plugin;
+export {
+  server_default as default
+};

package/dist/tui/index.d.ts

@@ -0,0 +1,3 @@
+import type { TuiPluginModule } from "@opencode-ai/plugin/tui";
+declare const plugin: TuiPluginModule;
+export default plugin;

package/dist/tui/index.js

@@ -0,0 +1,423 @@
+// @bun
+// src/config/ConfigDefaults.ts
+class ConfigDefaults {
+  static getDefaultSkillMappings() {
+    return {
+      "feature-planning": "feature-planning",
+      "plan-execute": "plan-execute",
+      "plan-resync": "plan-resync",
+      "plan-review": "plan-review",
+      "plan-split": "plan-split"
+    };
+  }
+  static getDefaultConfig() {
+    return {
+      planDirectory: "docs/_planning",
+      skillMappings: this.getDefaultSkillMappings()
+    };
+  }
+}
+// src/config/ConfigTypes.ts
+var skillCommands = [
+  "feature-planning",
+  "plan-execute",
+  "plan-resync",
+  "plan-review",
+  "plan-split"
+];
+
+class ConfigTypes {
+  static getSkillCommands() {
+    return [...skillCommands];
+  }
+}
+
+// src/config/ConfigMerger.ts
+class ConfigMerger {
+  static merge(userConfig) {
+    const config = ConfigDefaults.getDefaultConfig();
+    if (userConfig.planDirectory !== undefined) {
+      config.planDirectory = userConfig.planDirectory;
+    }
+    if (userConfig.skillMappings !== undefined) {
+      for (const command of ConfigTypes.getSkillCommands()) {
+        config.skillMappings[command] = userConfig.skillMappings[command] ?? config.skillMappings[command];
+      }
+    }
+    return config;
+  }
+}
+
+// src/config/ConfigValidator.ts
+class ConfigValidator {
+  static validate(config) {
+    const errors = [];
+    if (config.planDirectory.trim() === "") {
+      errors.push("Invalid planDirectory: must be a non-empty string.");
+    }
+    for (const command of ConfigTypes.getSkillCommands()) {
+      if (config.skillMappings[command].trim() === "") {
+        errors.push(`Invalid skillMappings.${command}: must be a non-empty string.`);
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  static validateOrThrow(config) {
+    const result = this.validate(config);
+    if (!result.valid) {
+      throw new Error(`Invalid configuration:
+${result.errors.join(`
+`)}`);
+    }
+  }
+}
+
+// src/config/ConfigLoader.ts
+class ConfigLoader {
+  static stringOption(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+  }
+  static planDirectoryOption(value) {
+    const directory = this.stringOption(value)?.replace(/\/+$/, "");
+    return directory === "" ? undefined : directory;
+  }
+  static skillMappingsOption(value) {
+    if (typeof value !== "object" || value === null) {
+      return;
+    }
+    const mappingOptions = value;
+    const skillMappings = {};
+    for (const command of ConfigTypes.getSkillCommands()) {
+      const skill = this.stringOption(mappingOptions[command]);
+      if (skill !== undefined) {
+        skillMappings[command] = skill;
+      }
+    }
+    return skillMappings;
+  }
+  static getUserConfig(options) {
+    const planDirectory = this.planDirectoryOption(options?.planDirectory);
+    const skillMappings = this.skillMappingsOption(options?.skillMappings);
+    return {
+      ...planDirectory === undefined ? {} : { planDirectory },
+      ...skillMappings === undefined ? {} : { skillMappings }
+    };
+  }
+  static loadConfig(options) {
+    try {
+      const config = ConfigMerger.merge(this.getUserConfig(options));
+      ConfigValidator.validateOrThrow(config);
+      return config;
+    } catch {
+      return ConfigDefaults.getDefaultConfig();
+    }
+  }
+}
+// src/lib/FilePickerCommands.ts
+import { createComponent } from "@opentui/solid";
+import { readdirSync, statSync } from "fs";
+import { join, resolve } from "path";
+import { pathToFileURL } from "url";
+
+class FilePickerCommands {
+  static isPlanPath(path, planDirectory) {
+    return path.startsWith(`${planDirectory}/`) && path.endsWith("/plan.md") && !path.slice(planDirectory.length + 1, -"/plan.md".length).includes("/") && !/\s/.test(path.slice(planDirectory.length + 1, -"/plan.md".length));
+  }
+  static planOptions(root, planDirectory, excludesPlanningDirectory = () => false) {
+    const planningDirectory = join(root, planDirectory);
+    try {
+      return readdirSync(planningDirectory, { withFileTypes: true }).filter((entry) => {
+        if (!entry.isDirectory()) {
+          return false;
+        }
+        if (excludesPlanningDirectory(join(planningDirectory, entry.name))) {
+          return false;
+        }
+        try {
+          return statSync(join(planningDirectory, entry.name, "plan.md")).isFile();
+        } catch {
+          return false;
+        }
+      }).map((entry) => ({
+        argument: `${planDirectory}/${entry.name}/plan.md`,
+        filePath: `${planDirectory}/${entry.name}/plan.md`,
+        label: entry.name
+      })).sort((left, right) => left.label.localeCompare(right.label));
+    } catch {
+      return [];
+    }
+  }
+  static hasSubPlans(directory) {
+    try {
+      return readdirSync(directory, { withFileTypes: true }).some((entry) => entry.isFile() && /^\d{2}-.+\.md$/.test(entry.name));
+    } catch {
+      return false;
+    }
+  }
+  static isSubPlanSelection(argument, filePath, planDirectory) {
+    return argument.startsWith(`${planDirectory}/`) && !argument.slice(planDirectory.length + 1).includes("/") && !/\s/.test(argument.slice(planDirectory.length + 1)) && filePath.startsWith(`${argument}/`) && filePath !== `${argument}/plan.md` && filePath.endsWith(".md");
+  }
+  static subPlanOptions(root, planDirectory) {
+    const planningDirectory = join(root, planDirectory);
+    try {
+      return readdirSync(planningDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
+        const directory = join(planningDirectory, entry.name);
+        try {
+          const subPlan = readdirSync(directory, { withFileTypes: true }).filter((file) => file.isFile() && file.name !== "plan.md" && file.name.endsWith(".md")).map((file) => file.name).sort((left, right) => left.localeCompare(right))[0];
+          return subPlan === undefined ? [] : [{
+            argument: `${planDirectory}/${entry.name}`,
+            filePath: `${planDirectory}/${entry.name}/${subPlan}`,
+            label: entry.name
+          }];
+        } catch {
+          return [];
+        }
+      }).sort((left, right) => left.label.localeCompare(right.label));
+    } catch {
+      return [];
+    }
+  }
+  static getCommands(config) {
+    const { planDirectory, skillMappings } = config;
+    const noPlansMessage = `No plan.md files found in ${planDirectory}.`;
+    const noSubPlansMessage = `No sub-plan files found in ${planDirectory}.`;
+    return [
+      {
+        argumentPlaceholder: "$ARGUMENTS",
+        command: "plan-review",
+        description: "Select a plan to review",
+        emptyMessage: noPlansMessage,
+        matchesSelection: (argument, filePath) => argument === filePath && FilePickerCommands.isPlanPath(argument, planDirectory),
+        options: (root, excludesPlanningDirectory) => FilePickerCommands.planOptions(root, planDirectory, excludesPlanningDirectory),
+        retainsSelectedFileInPrompt: true,
+        skill: skillMappings["plan-review"],
+        title: "Select a plan to review"
+      },
+      {
+        argumentPlaceholder: "$ARGUMENTS",
+        command: "plan-split",
+        description: "Select a plan to split",
+        emptyMessage: noPlansMessage,
+        excludesPlanningDirectory: FilePickerCommands.hasSubPlans,
+        matchesSelection: (argument, filePath) => argument === filePath && FilePickerCommands.isPlanPath(argument, planDirectory),
+        options: (root, excludesPlanningDirectory) => FilePickerCommands.planOptions(root, planDirectory, excludesPlanningDirectory),
+        retainsSelectedFileInPrompt: true,
+        skill: skillMappings["plan-split"],
+        title: "Select a plan to split"
+      },
+      {
+        argumentPlaceholder: "$PLAN_DIR",
+        command: "plan-execute",
+        description: "Select sub-plans to execute",
+        emptyMessage: noSubPlansMessage,
+        matchesSelection: (argument, filePath) => FilePickerCommands.isSubPlanSelection(argument, filePath, planDirectory),
+        options: (root) => FilePickerCommands.subPlanOptions(root, planDirectory),
+        retainsSelectedFileInPrompt: false,
+        skill: skillMappings["plan-execute"],
+        title: "Select sub-plans to execute"
+      }
+    ];
+  }
+  static findSkill(text, parts, config) {
+    const filePaths = parts.flatMap((part) => {
+      if (typeof part !== "object" || part === null || !("type" in part) || part.type !== "file" || !("source" in part)) {
+        return [];
+      }
+      const { source } = part;
+      return typeof source === "object" && source !== null && "type" in source && source.type === "file" && "path" in source && typeof source.path === "string" ? [source.path] : [];
+    });
+    for (const command of FilePickerCommands.getCommands(config)) {
+      const prefix = `/${command.command} @`;
+      if (!text.startsWith(prefix)) {
+        continue;
+      }
+      const argument = text.slice(prefix.length).trim();
+      const filePath = filePaths.find((path) => command.matchesSelection(argument, path));
+      if (argument !== "" && filePath !== undefined) {
+        return {
+          argument,
+          argumentPlaceholder: command.argumentPlaceholder,
+          filePath,
+          retainsSelectedFileInPrompt: command.retainsSelectedFileInPrompt,
+          skill: command.skill
+        };
+      }
+    }
+  }
+  static removeSelectedFile(parts, filePath) {
+    const selectedFileIndex = parts.findIndex((candidate) => {
+      if (typeof candidate !== "object" || candidate === null || !("type" in candidate) || candidate.type !== "file" || !("source" in candidate)) {
+        return false;
+      }
+      const { source } = candidate;
+      return typeof source === "object" && source !== null && "type" in source && source.type === "file" && "path" in source && source.path === filePath;
+    });
+    if (selectedFileIndex !== -1) {
+      parts.splice(selectedFileIndex, 1);
+    }
+  }
+  static expandedSkill(text, parts, commands) {
+    for (const part of parts) {
+      if (typeof part !== "object" || part === null || !("type" in part) || part.type !== "file" || !("source" in part)) {
+        continue;
+      }
+      const { source } = part;
+      if (typeof source !== "object" || source === null || !("type" in source) || source.type !== "file" || !("path" in source) || !("text" in source)) {
+        continue;
+      }
+      const filePath = source.path;
+      if (typeof filePath !== "string" || typeof source.text !== "object" || source.text === null || !("value" in source.text) || typeof source.text.value !== "string" || !source.text.value.startsWith("@")) {
+        continue;
+      }
+      const argument = source.text.value.slice(1);
+      const command = commands.find((candidate) => candidate.matchesSelection(argument, filePath) && text.includes(candidate.argumentPlaceholder));
+      if (command !== undefined) {
+        return {
+          argument,
+          argumentPlaceholder: command.argumentPlaceholder,
+          filePath,
+          retainsSelectedFileInPrompt: command.retainsSelectedFileInPrompt,
+          skill: command.skill
+        };
+      }
+    }
+  }
+  static async expand(output, template, config) {
+    const commands = FilePickerCommands.getCommands(config);
+    for (const part of output.parts) {
+      if (typeof part !== "object" || part === null || !("type" in part) || part.type !== "text" || !("text" in part) || typeof part.text !== "string" || "synthetic" in part && part.synthetic) {
+        continue;
+      }
+      const skill = FilePickerCommands.findSkill(part.text, output.parts, config);
+      if (skill === undefined) {
+        continue;
+      }
+      part.text = (await template(skill.skill)).replaceAll(skill.argumentPlaceholder, `@${skill.argument}`).trim();
+      if (!skill.retainsSelectedFileInPrompt) {
+        FilePickerCommands.removeSelectedFile(output.parts, skill.filePath);
+      }
+      return;
+    }
+    for (const part of output.parts) {
+      if (typeof part !== "object" || part === null || !("type" in part) || part.type !== "text" || !("text" in part) || typeof part.text !== "string" || "synthetic" in part && part.synthetic) {
+        continue;
+      }
+      const skill = FilePickerCommands.expandedSkill(part.text, output.parts, commands);
+      if (skill === undefined) {
+        continue;
+      }
+      part.text = part.text.replaceAll(skill.argumentPlaceholder, `@${skill.argument}`);
+      if (!skill.retainsSelectedFileInPrompt) {
+        FilePickerCommands.removeSelectedFile(output.parts, skill.filePath);
+      }
+      return;
+    }
+  }
+  static workspaceRoot(worktree, directory) {
+    return worktree === "/" ? directory : worktree;
+  }
+  static setPrompt(prompt, root, command, option) {
+    const mention = `@${option.argument}`;
+    const input = `/${command.command} ${mention} `;
+    const start = Bun.stringWidth(`/${command.command} `);
+    prompt.set({
+      input,
+      mode: "normal",
+      parts: [
+        {
+          type: "file",
+          mime: "text/plain",
+          filename: option.filePath,
+          url: pathToFileURL(resolve(root, option.filePath)).href,
+          source: {
+            type: "file",
+            path: option.filePath,
+            text: {
+              start,
+              end: start + Bun.stringWidth(mention),
+              value: mention
+            }
+          }
+        }
+      ]
+    });
+    prompt.focus();
+  }
+  static register(api, prompt, config) {
+    api.keymap.registerLayer({
+      commands: FilePickerCommands.getCommands(config).map((command) => ({
+        name: `encoredigitalgroup-opencode.${command.command}`,
+        title: command.title,
+        category: "Plugin",
+        namespace: "palette",
+        slashName: command.command,
+        run() {
+          const root = FilePickerCommands.workspaceRoot(api.state.path.worktree, api.state.path.directory);
+          const options = command.options(root, command.excludesPlanningDirectory);
+          if (options.length === 0) {
+            api.ui.toast({
+              variant: "warning",
+              message: command.emptyMessage
+            });
+            return;
+          }
+          const DialogSelect = api.ui.DialogSelect;
+          api.ui.dialog.setSize("medium");
+          api.ui.dialog.replace(() => createComponent(DialogSelect, {
+            title: command.title,
+            options: options.map((option) => ({ title: option.label, value: option })),
+            onSelect: (option) => {
+              api.ui.dialog.clear();
+              const promptRef = prompt();
+              if (promptRef === undefined) {
+                api.ui.toast({
+                  variant: "error",
+                  message: "The prompt is not ready."
+                });
+                return;
+              }
+              FilePickerCommands.setPrompt(promptRef, root, command, option.value);
+            }
+          }));
+        }
+      }))
+    });
+  }
+}
+
+// src/tui/index.tsx
+import { jsx } from "@opentui/solid/jsx-runtime";
+var plugin = {
+  id: "encoredigitalgroup-opencode",
+  tui: async (api, options) => {
+    let prompt;
+    const Prompt = api.ui.Prompt;
+    const capturePrompt = (value, ref) => {
+      prompt = value;
+      ref?.(value);
+    };
+    api.slots.register({
+      slots: {
+        home_prompt(_context, props) {
+          return /* @__PURE__ */ jsx(Prompt, {
+            ref: (value) => capturePrompt(value, props.ref)
+          });
+        },
+        session_prompt(_context, props) {
+          return /* @__PURE__ */ jsx(Prompt, {
+            sessionID: props.session_id,
+            visible: props.visible,
+            disabled: props.disabled,
+            onSubmit: props.on_submit,
+            ref: (value) => capturePrompt(value, props.ref)
+          });
+        }
+      }
+    });
+    FilePickerCommands.register(api, () => prompt, ConfigLoader.loadConfig(options));
+  }
+};
+var tui_default = plugin;
+export {
+  tui_default as default
+};

package/package.json

@@ -0,0 +1,65 @@
+{
+    "name": "@encoredigitalgroup/opencode",
+    "type": "module",
+    "version": "0.1.0",
+    "description": "OpenCode file-picker commands for planning skills.",
+    "publishConfig": {
+        "access": "public"
+    },
+    "keywords": [
+        "opencode",
+        "opencode-plugin",
+        "planning",
+        "skills"
+    ],
+    "engines": {
+        "bun": ">=1.4.0"
+    },
+    "devDependencies": {
+        "@opencode-ai/plugin": "1.18.29",
+        "@opentui/core": "0.4.5",
+        "@opentui/keymap": "0.4.5",
+        "@opentui/solid": "0.4.5",
+        "@types/bun": "1.4.0",
+        "tsfmt": "^0.3.0-beta9",
+        "typescript": "5.8.2"
+    },
+    "scripts": {
+        "build": "rm -rf dist && bun build src/server/index.ts src/tui/index.tsx --outdir dist --target bun --external '@opencode-ai/plugin' --external '@opencode-ai/plugin/*' --external '@opentui/solid' --external '@opentui/solid/*' && tsc --emitDeclarationOnly",
+        "check": "bun run typecheck && bun run build",
+        "pack:check": "bun pm pack --dry-run",
+        "typecheck": "tsc --noEmit"
+    },
+    "types": "./dist/server/index.d.ts",
+    "main": "./dist/server/index.js",
+    "exports": {
+        ".": {
+            "types": "./dist/server/index.d.ts",
+            "default": "./dist/server/index.js"
+        },
+        "./server": {
+            "types": "./dist/server/index.d.ts",
+            "default": "./dist/server/index.js"
+        },
+        "./tui": {
+            "types": "./dist/tui/index.d.ts",
+            "default": "./dist/tui/index.js"
+        }
+    },
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE.md"
+    ],
+    "license": "proprietary",
+    "peerDependencies": {
+        "@opencode-ai/plugin": "^1.18.29",
+        "@opentui/core": "^0.4.5",
+        "@opentui/keymap": "^0.4.5",
+        "@opentui/solid": "^0.4.5"
+    },
+    "oc-plugin": [
+        "server",
+        "tui"
+    ]
+}