@rexeus/agentic 0.3.1

package/bin/agentic.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+import { doctorOpenCode } from "../opencode/doctor.mjs";
+import { installOpenCode } from "../opencode/install.mjs";
+import { uninstallOpenCode } from "../opencode/uninstall.mjs";
+
+const printUsage = () => {
+  console.log(`Usage:
+  agentic install opencode
+  agentic uninstall opencode
+  agentic doctor`);
+};
+
+const fail = (message) => {
+  console.error(`agentic: ${message}`);
+  process.exit(1);
+};
+
+const printAssetDoctorStatus = (label, installedLabel, missingLabel, conflictLabel, status) => {
+  console.log(`${label} dir: ${status.dir}`);
+  console.log(`${label} present: ${status.presentFiles.length > 0 ? "yes" : "no"}`);
+
+  if (status.missingFiles.length === 0 && status.conflictingFiles.length === 0) {
+    console.log(`${installedLabel}: yes`);
+    return;
+  }
+
+  console.log(
+    `${installedLabel}: no (${status.conflictingFiles.length} conflicting, ${status.missingFiles.length} missing)`,
+  );
+
+  for (const fileName of status.conflictingFiles) {
+    console.log(`- ${conflictLabel}: ${fileName}`);
+  }
+
+  for (const fileName of status.missingFiles) {
+    console.log(`- ${missingLabel}: ${fileName}`);
+  }
+};
+
+const run = async () => {
+  const command = process.argv[2];
+  const target = process.argv[3];
+
+  if (command === "install") {
+    if (target !== "opencode") {
+      fail("expected target 'opencode'");
+    }
+
+    const result = await installOpenCode();
+    console.log(`Installed OpenCode integration.`);
+    console.log(`Config: ${result.configPath}`);
+    if (result.backupPath) {
+      console.log(`Backup: ${result.backupPath}`);
+    }
+    console.log(`Commands: ${result.commandsDir}`);
+    console.log(`Agents: ${result.agentsDir}`);
+    console.log(`Skills: ${result.skillsDir}`);
+    if (
+      result.conflicts.commands.length > 0 ||
+      result.conflicts.agents.length > 0 ||
+      result.conflicts.skills.length > 0
+    ) {
+      console.log("Conflicts detected with existing unowned OpenCode assets:");
+      for (const commandName of result.conflicts.commands) {
+        console.log(`- command conflict: ${commandName}`);
+      }
+      for (const agentName of result.conflicts.agents) {
+        console.log(`- agent conflict: ${agentName}`);
+      }
+      for (const skillName of result.conflicts.skills) {
+        console.log(`- skill conflict: ${skillName}`);
+      }
+    }
+    return;
+  }
+
+  if (command === "uninstall") {
+    if (target !== "opencode") {
+      fail("expected target 'opencode'");
+    }
+
+    const result = await uninstallOpenCode();
+    console.log(`Removed OpenCode integration.`);
+    console.log(`Config: ${result.configPath}`);
+    if (result.backupPath) {
+      console.log(`Backup: ${result.backupPath}`);
+    }
+    console.log(`Removed commands: ${result.removedCommands}`);
+    console.log(`Removed agents: ${result.removedAgents}`);
+    console.log(`Removed skills: ${result.removedSkills}`);
+    return;
+  }
+
+  if (command === "doctor") {
+    const result = await doctorOpenCode();
+    console.log("Agentic OpenCode Doctor");
+    console.log(`Config: ${result.configPath}`);
+    if (result.configError) {
+      console.log(`Config valid: no`);
+      console.log(`Config error: ${result.configError}`);
+    } else {
+      console.log(`Config valid: yes`);
+    }
+    console.log(`Plugin installed: ${result.pluginInstalled ? "yes" : "no"}`);
+    console.log(`Plugin via config: ${result.pluginSources.config ? "yes" : "no"}`);
+    console.log(`Plugin local files: ${result.pluginSources.localFiles.length}`);
+    for (const pluginFile of result.pluginSources.localFiles) {
+      console.log(`- plugin file: ${pluginFile}`);
+    }
+    printAssetDoctorStatus("Commands", "Commands installed", "missing", "command conflict", {
+      dir: result.commandsDir,
+      presentFiles: result.commands.presentFiles,
+      conflictingFiles: result.commands.conflictingFiles,
+      missingFiles: result.commands.missingFiles,
+    });
+    printAssetDoctorStatus("Agents", "Agents installed", "missing agent", "agent conflict", {
+      dir: result.agentsDir,
+      presentFiles: result.agents.presentFiles,
+      conflictingFiles: result.agents.conflictingFiles,
+      missingFiles: result.agents.missingFiles,
+    });
+    printAssetDoctorStatus("Skills", "Skills installed", "missing skill", "skill conflict", {
+      dir: result.skillsDir,
+      presentFiles: result.skills.presentFiles,
+      conflictingFiles: result.skills.conflictingFiles,
+      missingFiles: result.skills.missingFiles,
+    });
+
+    return;
+  }
+
+  printUsage();
+  process.exit(1);
+};
+
+run().catch((error) => {
+  fail(error instanceof Error ? error.message : String(error));
+});

package/opencode/config.mjs

@@ -0,0 +1,453 @@
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { cp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { applyEdits, modify, parse, printParseErrorCode } from "jsonc-parser";
+
+import {
+  AGENT_FILES,
+  COMMAND_FILES,
+  LOCAL_PLUGIN_PREFIX,
+  PLUGIN_NAME,
+  SKILL_NAMES,
+} from "./manifest.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const projectRoot = resolve(__dirname, "..");
+
+const AGENT_MARKER = "Generated by pnpm run sync:opencode-agents";
+const COMMAND_MARKER = "Installed by @rexeus/agentic command";
+const SKILL_MARKER = "Installed by @rexeus/agentic";
+
+export const getOpenCodeConfigDir = () => {
+  if (
+    typeof process.env.OPENCODE_CONFIG_DIR === "string" &&
+    process.env.OPENCODE_CONFIG_DIR.trim()
+  ) {
+    return process.env.OPENCODE_CONFIG_DIR;
+  }
+
+  if (typeof process.env.HOME !== "string" || process.env.HOME.length === 0) {
+    throw new Error("Unable to resolve home directory");
+  }
+
+  return join(process.env.HOME, ".config", "opencode");
+};
+
+export const ensureOpenCodeConfigDir = () => {
+  const configDir = getOpenCodeConfigDir();
+  mkdirSync(configDir, { recursive: true });
+  return configDir;
+};
+
+const formatConfigError = (configPath, message) =>
+  `Invalid OpenCode config at ${configPath}: ${message}`;
+
+const getPluginConfigError = (configPath, config) => {
+  if (Object.hasOwn(config, "plugin") && !Array.isArray(config.plugin)) {
+    return formatConfigError(
+      configPath,
+      "expected 'plugin' to be an array when present. No changes were made.",
+    );
+  }
+
+  return null;
+};
+
+const getParsedConfig = (raw, configPath) => {
+  const errors = [];
+  const parsed = parse(raw, errors);
+
+  if (errors.length > 0) {
+    const [firstError] = errors;
+    return {
+      config: null,
+      error: formatConfigError(
+        configPath,
+        `${printParseErrorCode(firstError.error)} at offset ${firstError.offset}. No changes were made.`,
+      ),
+    };
+  }
+
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return {
+      config: null,
+      error: formatConfigError(configPath, "expected a JSON object. No changes were made."),
+    };
+  }
+
+  return { config: parsed, error: null };
+};
+
+const getConfigPath = (configDir) => {
+  const jsoncPath = join(configDir, "opencode.jsonc");
+  if (existsSync(jsoncPath)) {
+    return jsoncPath;
+  }
+
+  const jsonPath = join(configDir, "opencode.json");
+  if (existsSync(jsonPath)) {
+    return jsonPath;
+  }
+
+  return jsonPath;
+};
+
+const getProjectConfigDir = () => join(process.cwd(), ".opencode");
+
+const insertMarkerAfterFrontmatter = (content, marker) => {
+  const match = content.match(/^---\n[\s\S]*?\n---\n\n?/);
+  if (!match) {
+    return `<!-- ${marker} -->\n\n${content}`;
+  }
+
+  const body = content.slice(match[0].length);
+  return `${match[0]}<!-- ${marker} -->\n\n${body}`;
+};
+
+const isMarkedFile = async (filePath, marker) => {
+  try {
+    const content = await readFile(filePath, "utf8");
+    return content.includes(marker);
+  } catch {
+    return false;
+  }
+};
+
+const hasOwnPluginKey = (config) => Object.hasOwn(config, "plugin");
+
+const getPluginEntryName = (entry) => {
+  if (typeof entry === "string") {
+    return entry;
+  }
+
+  if (Array.isArray(entry) && typeof entry[0] === "string") {
+    return entry[0];
+  }
+
+  return null;
+};
+
+const isAgenticPluginName = (name) =>
+  typeof name === "string" && (name === PLUGIN_NAME || name.startsWith(`${PLUGIN_NAME}@`));
+
+const isAgenticPluginEntry = (entry) => isAgenticPluginName(getPluginEntryName(entry));
+
+const getMarkedAssetStatus = async ({ files, marker, resolveTargetPath }) => {
+  const installedFiles = [];
+  const conflictingFiles = [];
+  const missingFiles = [];
+
+  for (const fileName of files) {
+    const targetPath = resolveTargetPath(fileName);
+    if (!existsSync(targetPath)) {
+      missingFiles.push(fileName);
+      continue;
+    }
+
+    if (marker && (await isMarkedFile(targetPath, marker))) {
+      installedFiles.push(fileName);
+      continue;
+    }
+
+    conflictingFiles.push(fileName);
+  }
+
+  return {
+    installedFiles,
+    conflictingFiles,
+    missingFiles,
+    presentFiles: [...installedFiles, ...conflictingFiles],
+  };
+};
+
+const installAssetFiles = async ({ files, sourceDir, targetDir, marker }) => {
+  mkdirSync(targetDir, { recursive: true });
+
+  for (const fileName of files) {
+    const sourcePath = join(sourceDir, fileName);
+    const targetPath = join(targetDir, fileName);
+    if (existsSync(targetPath) && marker && !(await isMarkedFile(targetPath, marker))) {
+      continue;
+    }
+
+    const sourceContent = readFileSync(sourcePath, "utf8");
+    const output = marker ? insertMarkerAfterFrontmatter(sourceContent, marker) : sourceContent;
+    await writeFile(targetPath, output, "utf8");
+  }
+
+  return targetDir;
+};
+
+const removeMarkedFiles = async ({ files, targetDir, marker }) => {
+  let removed = 0;
+
+  for (const fileName of files) {
+    const targetPath = join(targetDir, fileName);
+    if (!existsSync(targetPath)) {
+      continue;
+    }
+
+    if (marker && !(await isMarkedFile(targetPath, marker))) {
+      continue;
+    }
+
+    await rm(targetPath, { force: true });
+    removed += 1;
+  }
+
+  return removed;
+};
+
+const detectLocalPluginFiles = async (pluginsDir) => {
+  if (!existsSync(pluginsDir)) {
+    return [];
+  }
+
+  const entries = await readdir(pluginsDir, { withFileTypes: true });
+  const matches = [];
+
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+
+    if (
+      !entry.name.endsWith(".js") &&
+      !entry.name.endsWith(".mjs") &&
+      !entry.name.endsWith(".ts")
+    ) {
+      continue;
+    }
+
+    const filePath = join(pluginsDir, entry.name);
+    try {
+      const content = await readFile(filePath, "utf8");
+      if (
+        entry.name.startsWith(LOCAL_PLUGIN_PREFIX) ||
+        content.includes("AgenticPlugin") ||
+        content.includes(PLUGIN_NAME) ||
+        content.includes("/opencode/plugin.mjs")
+      ) {
+        matches.push(filePath);
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return matches;
+};
+
+export const readOpenCodeConfig = (configDir) => {
+  const configPath = getConfigPath(configDir);
+  if (!existsSync(configPath)) {
+    return { configPath, config: {}, error: null };
+  }
+
+  const raw = readFileSync(configPath, "utf8");
+  const { config, error } = getParsedConfig(raw, configPath);
+
+  return { configPath, config, error };
+};
+
+export const validateOpenCodeConfigForMutation = (configPath, config) =>
+  getPluginConfigError(configPath, config);
+
+export const backupConfigFile = async (configPath) => {
+  if (!existsSync(configPath)) {
+    return null;
+  }
+
+  const backupPath = `${configPath}.bak.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+  await cp(configPath, backupPath);
+  return backupPath;
+};
+
+export const writeOpenCodeConfig = async (configPath, config) => {
+  if (configPath.endsWith(".jsonc") && existsSync(configPath)) {
+    const raw = readFileSync(configPath, "utf8");
+    const { config: parsed, error } = getParsedConfig(raw, configPath);
+
+    if (error) {
+      throw new Error(error);
+    }
+
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const edits = modify(raw, ["plugin"], hasOwnPluginKey(config) ? config.plugin : undefined, {
+        formattingOptions: {
+          insertSpaces: true,
+          tabSize: 2,
+        },
+      });
+      const normalized = `${applyEdits(raw, edits).trimEnd()}\n`;
+      await writeFile(configPath, normalized, "utf8");
+      return;
+    }
+  }
+
+  const normalized = `${JSON.stringify(config, null, 2)}\n`;
+  await writeFile(configPath, normalized, "utf8");
+};
+
+export const ensurePluginEntry = (config) => {
+  const plugins = Array.isArray(config.plugin) ? [...config.plugin] : [];
+  const existingAgenticEntry = plugins.find(isAgenticPluginEntry);
+  const withoutAgentic = plugins.filter((entry) => !isAgenticPluginEntry(entry));
+  withoutAgentic.push(Array.isArray(existingAgenticEntry) ? existingAgenticEntry : PLUGIN_NAME);
+  return { ...config, plugin: withoutAgentic };
+};
+
+export const removePluginEntry = (config) => {
+  const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+  const filtered = plugins.filter((entry) => !isAgenticPluginEntry(entry));
+
+  if (filtered.length > 0) {
+    return { ...config, plugin: filtered };
+  }
+
+  const { plugin: _plugin, ...rest } = config;
+  return rest;
+};
+
+export const installGlobalCommands = async (configDir) =>
+  installAssetFiles({
+    files: COMMAND_FILES,
+    sourceDir: join(projectRoot, "assets", "opencode", "commands"),
+    targetDir: join(configDir, "commands"),
+    marker: COMMAND_MARKER,
+  });
+
+export const installGlobalAgents = async (configDir) =>
+  installAssetFiles({
+    files: AGENT_FILES,
+    sourceDir: join(projectRoot, "assets", "opencode", "agents"),
+    targetDir: join(configDir, "agents"),
+    marker: AGENT_MARKER,
+  });
+
+export const installGlobalSkills = async (configDir) => {
+  const skillsDir = join(configDir, "skills");
+  mkdirSync(skillsDir, { recursive: true });
+
+  for (const skillName of SKILL_NAMES) {
+    const sourcePath = join(projectRoot, "skills", skillName, "SKILL.md");
+    const targetDir = join(skillsDir, skillName);
+    const targetPath = join(targetDir, "SKILL.md");
+
+    if (existsSync(targetPath) && !(await isMarkedFile(targetPath, SKILL_MARKER))) {
+      continue;
+    }
+
+    mkdirSync(targetDir, { recursive: true });
+    const sourceContent = readFileSync(sourcePath, "utf8");
+    await writeFile(targetPath, insertMarkerAfterFrontmatter(sourceContent, SKILL_MARKER), "utf8");
+  }
+
+  return skillsDir;
+};
+
+export const uninstallGlobalCommands = async (configDir) => {
+  const commandsDir = join(configDir, "commands");
+  if (!existsSync(commandsDir)) {
+    return 0;
+  }
+
+  return removeMarkedFiles({
+    files: COMMAND_FILES,
+    targetDir: commandsDir,
+    marker: COMMAND_MARKER,
+  });
+};
+
+export const uninstallGlobalAgents = async (configDir) => {
+  const agentsDir = join(configDir, "agents");
+  if (!existsSync(agentsDir)) {
+    return 0;
+  }
+
+  return removeMarkedFiles({ files: AGENT_FILES, targetDir: agentsDir, marker: AGENT_MARKER });
+};
+
+export const uninstallGlobalSkills = async (configDir) => {
+  const skillsDir = join(configDir, "skills");
+  if (!existsSync(skillsDir)) {
+    return 0;
+  }
+
+  let removed = 0;
+
+  for (const skillName of SKILL_NAMES) {
+    const targetDir = join(skillsDir, skillName);
+    const targetPath = join(targetDir, "SKILL.md");
+    if (!existsSync(targetPath)) {
+      continue;
+    }
+
+    if (!(await isMarkedFile(targetPath, SKILL_MARKER))) {
+      continue;
+    }
+
+    await rm(targetPath, { force: true });
+
+    const remainingEntries = await readdir(targetDir);
+    if (remainingEntries.length === 0) {
+      await rm(targetDir, { recursive: true, force: true });
+    }
+
+    removed += 1;
+  }
+
+  return removed;
+};
+
+export const getDoctorStatus = async (configDir, config) => {
+  const plugins = Array.isArray(config.plugin) ? config.plugin : [];
+  const pluginFromConfig = plugins.some((entry) => isAgenticPluginEntry(entry));
+
+  const globalPluginFiles = await detectLocalPluginFiles(join(configDir, "plugins"));
+  const projectPluginFiles = await detectLocalPluginFiles(join(getProjectConfigDir(), "plugins"));
+  const localPluginFiles = [...globalPluginFiles, ...projectPluginFiles];
+
+  const commandsDir = join(configDir, "commands");
+  const agentsDir = join(configDir, "agents");
+  const skillsDir = join(configDir, "skills");
+
+  const commandStatus = await getMarkedAssetStatus({
+    files: COMMAND_FILES,
+    marker: COMMAND_MARKER,
+    resolveTargetPath: (commandFile) => join(commandsDir, commandFile),
+  });
+  const agentStatus = await getMarkedAssetStatus({
+    files: AGENT_FILES,
+    marker: AGENT_MARKER,
+    resolveTargetPath: (agentFile) => join(agentsDir, agentFile),
+  });
+  const skillStatus = await getMarkedAssetStatus({
+    files: SKILL_NAMES,
+    marker: SKILL_MARKER,
+    resolveTargetPath: (skillName) => join(skillsDir, skillName, "SKILL.md"),
+  });
+
+  return {
+    pluginInstalled: pluginFromConfig || localPluginFiles.length > 0,
+    pluginSources: {
+      config: pluginFromConfig,
+      localFiles: localPluginFiles,
+    },
+    commandsDir,
+    agentsDir,
+    skillsDir,
+    commands: commandStatus,
+    agents: agentStatus,
+    skills: skillStatus,
+    missingCommands: commandStatus.missingFiles,
+    missingAgents: agentStatus.missingFiles,
+    missingSkills: skillStatus.missingFiles,
+    conflictingCommands: commandStatus.conflictingFiles,
+    conflictingAgents: agentStatus.conflictingFiles,
+    conflictingSkills: skillStatus.conflictingFiles,
+  };
+};

package/opencode/doctor.mjs

@@ -0,0 +1,9 @@
+import { getDoctorStatus, getOpenCodeConfigDir, readOpenCodeConfig } from "./config.mjs";
+
+export const doctorOpenCode = async () => {
+  const configDir = getOpenCodeConfigDir();
+  const { configPath, config, error } = readOpenCodeConfig(configDir);
+  const status = await getDoctorStatus(configDir, config ?? {});
+
+  return { configPath, configError: error, ...status };
+};