opencode-athena 0.2.0 → 0.4.0

package/dist/plugin/index.js

@@ -71,19 +71,66 @@ function handleSessionError(event, tracker) {
 }
 
 // src/plugin/hooks/tool-hooks.ts
-function createToolHooks(_tracker, _config) {
+var GIT_WRITE_COMMANDS = [
+  "git commit",
+  "git push",
+  "git checkout -b",
+  "git branch ",
+  "git switch -c",
+  "git switch --create",
+  "git merge",
+  "git rebase",
+  "git cherry-pick",
+  "git stash",
+  "git tag",
+  "git reset",
+  "gh pr create",
+  "gh pr edit",
+  "gh pr merge",
+  "gh pr close",
+  "gh pr review",
+  "gh issue create",
+  "gh issue edit",
+  "gh issue close",
+  "gh release create",
+  "gh release edit",
+  "gh release delete"
+];
+function getBashCommand(metadata) {
+  if (!metadata || typeof metadata !== "object") {
+    return "";
+  }
+  const cmd = metadata.command;
+  return typeof cmd === "string" ? cmd : "";
+}
+function containsGitWriteCommand(command) {
+  const normalized = command.trim().toLowerCase();
+  const segments = normalized.split(/[;&|]+/).map((s) => s.trim());
+  return segments.some(
+    (segment) => GIT_WRITE_COMMANDS.some((gitCmd) => segment.startsWith(gitCmd.toLowerCase()))
+  );
+}
+function createToolHooks(_tracker, config) {
   return {
     /**
      * Called before a tool executes
-     * Can modify args or throw to block execution
      */
     before: async (_input, _output) => {
+      return;
     },
     /**
      * Called after a tool executes
-     * Can modify output or append messages
      */
-    after: async (_input, _output) => {
+    after: async (input, output) => {
+      if (config.features.autoGitOperations) {
+        return;
+      }
+      if (input.tool === "bash") {
+        const command = getBashCommand(output.metadata);
+        if (containsGitWriteCommand(command)) {
+          output.output += "\n\n\u26A0\uFE0F ATHENA GIT OPERATIONS POLICY REMINDER:\nGit operations should only be performed when explicitly requested by the user.\nIf this command was run automatically (not requested by the user), please:\n1. Ask the user before proceeding with further git operations\n2. Use athena_update_status() to track story progress instead of git commits\n\nTo enable automatic git operations, set features.autoGitOperations=true in athena.json";
+        }
+      }
     }
   };
 }
@@ -134,7 +181,8 @@ var DEFAULTS = {
     notifications: true,
     contextMonitor: true,
     commentChecker: true,
-    lspTools: true
+    lspTools: true,
+    autoGitOperations: false
   },
   /** Default MCPs enabled */
   mcps: {
@@ -1361,6 +1409,11 @@ var SubscriptionSchema = z.object({
   google: z.object({
     enabled: z.boolean(),
     authMethod: z.enum(["antigravity", "personal", "api", "none"])
+  }),
+  githubCopilot: z.object({
+    enabled: z.boolean(),
+    plan: z.enum(["free", "pro", "pro-plus", "business", "enterprise", "none"]),
+    enabledModels: z.array(z.string()).optional()
   })
 });
 var BmadConfigSchema = z.object({
@@ -1375,20 +1428,47 @@ var FeaturesSchema = z.object({
   notifications: z.boolean(),
   contextMonitor: z.boolean(),
   commentChecker: z.boolean(),
-  lspTools: z.boolean()
+  lspTools: z.boolean(),
+  autoGitOperations: z.boolean().default(false)
 });
 var McpsSchema = z.object({
   context7: z.boolean(),
   exa: z.boolean(),
   grepApp: z.boolean()
 });
+var ThinkingLevelSchema = z.enum(["off", "low", "medium", "high"]);
+var AgentSettingsSchema = z.object({
+  temperature: z.number().min(0).max(1).optional(),
+  thinkingLevel: ThinkingLevelSchema.optional()
+});
+var CustomModelDefinitionSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  provider: z.enum(["anthropic", "openai", "google", "github-copilot"]),
+  description: z.string().optional(),
+  capabilities: z.object({
+    thinking: z.boolean().optional(),
+    contextWindow: z.number().optional(),
+    supportsTemperature: z.boolean().optional()
+  }).optional()
+});
 var ModelsSchema = z.object({
   sisyphus: z.string().describe("Model for main orchestrator agent"),
   oracle: z.string().describe("Model for debugging/reasoning agent"),
   librarian: z.string().describe("Model for research/documentation agent"),
   frontend: z.string().optional().describe("Model for UI/UX agent"),
   documentWriter: z.string().optional().describe("Model for documentation generation agent"),
-  multimodalLooker: z.string().optional().describe("Model for image analysis agent")
+  multimodalLooker: z.string().optional().describe("Model for image analysis agent"),
+  settings: z.object({
+    sisyphus: AgentSettingsSchema.optional(),
+    oracle: AgentSettingsSchema.optional(),
+    librarian: AgentSettingsSchema.optional(),
+    frontend: AgentSettingsSchema.optional(),
+    documentWriter: AgentSettingsSchema.optional(),
+    multimodalLooker: AgentSettingsSchema.optional(),
+    overrides: z.record(z.string(), AgentSettingsSchema).optional()
+  }).optional(),
+  custom: z.array(CustomModelDefinitionSchema).optional()
 });
 var AthenaConfigSchema = z.object({
   $schema: z.string().optional(),
@@ -1520,22 +1600,37 @@ function validatePartialConfig(config, filePath) {
         authMethod: isValidAuthMethod(google.authMethod) ? google.authMethod : "none"
       };
     }
+    if (subs.githubCopilot && typeof subs.githubCopilot === "object") {
+      const copilot = subs.githubCopilot;
+      result.subscriptions.githubCopilot = {
+        enabled: typeof copilot.enabled === "boolean" ? copilot.enabled : false,
+        plan: isValidCopilotPlan(copilot.plan) ? copilot.plan : "none",
+        enabledModels: Array.isArray(copilot.enabledModels) ? copilot.enabledModels.filter((m) => typeof m === "string") : void 0
+      };
+    }
   }
   if ("models" in configObj && typeof configObj.models === "object") {
     const models = configObj.models;
     result.models = {};
-    for (const key of [
+    const modelKeys = [
       "sisyphus",
       "oracle",
       "librarian",
       "frontend",
       "documentWriter",
       "multimodalLooker"
-    ]) {
+    ];
+    for (const key of modelKeys) {
       if (key in models && typeof models[key] === "string") {
         result.models[key] = models[key];
       }
     }
+    if ("settings" in models && typeof models.settings === "object" && models.settings !== null) {
+      result.models.settings = validateModelSettings(models.settings);
+    }
+    if ("custom" in models && Array.isArray(models.custom)) {
+      result.models.custom = validateCustomModels(models.custom);
+    }
   }
   if ("bmad" in configObj && typeof configObj.bmad === "object") {
     const bmad = configObj.bmad;
@@ -1584,9 +1679,104 @@ function isValidTier(value) {
 function isValidAuthMethod(value) {
   return typeof value === "string" && ["antigravity", "personal", "api", "none"].includes(value);
 }
+function isValidCopilotPlan(value) {
+  return typeof value === "string" && ["free", "pro", "pro-plus", "business", "enterprise", "none"].includes(value);
+}
 function isValidTrack(value) {
   return typeof value === "string" && ["quick-flow", "bmad-method", "enterprise"].includes(value);
 }
+function isValidThinkingLevel(value) {
+  return typeof value === "string" && ["off", "low", "medium", "high"].includes(value);
+}
+function isValidProvider(value) {
+  return typeof value === "string" && ["anthropic", "openai", "google", "github-copilot"].includes(value);
+}
+function validateAgentSettings(settings) {
+  if (typeof settings !== "object" || settings === null) {
+    return void 0;
+  }
+  const result = {};
+  const settingsObj = settings;
+  const agentKeys = [
+    "sisyphus",
+    "oracle",
+    "librarian",
+    "frontend",
+    "documentWriter",
+    "multimodalLooker"
+  ];
+  for (const key of agentKeys) {
+    if (key in settingsObj && typeof settingsObj[key] === "object" && settingsObj[key] !== null) {
+      const agentSetting = settingsObj[key];
+      const validated = {};
+      if (typeof agentSetting.temperature === "number" && agentSetting.temperature >= 0 && agentSetting.temperature <= 2) {
+        validated.temperature = agentSetting.temperature;
+      }
+      if (isValidThinkingLevel(agentSetting.thinkingLevel)) {
+        validated.thinkingLevel = agentSetting.thinkingLevel;
+      }
+      if (Object.keys(validated).length > 0) {
+        result[key] = validated;
+      }
+    }
+  }
+  if ("overrides" in settingsObj && typeof settingsObj.overrides === "object" && settingsObj.overrides !== null) {
+    const overrides = settingsObj.overrides;
+    result.overrides = {};
+    for (const [modelId, modelSettings] of Object.entries(overrides)) {
+      if (typeof modelSettings === "object" && modelSettings !== null) {
+        const ms = modelSettings;
+        const validated = {};
+        if (typeof ms.temperature === "number" && ms.temperature >= 0 && ms.temperature <= 2) {
+          validated.temperature = ms.temperature;
+        }
+        if (isValidThinkingLevel(ms.thinkingLevel)) {
+          validated.thinkingLevel = ms.thinkingLevel;
+        }
+        if (Object.keys(validated).length > 0) {
+          result.overrides[modelId] = validated;
+        }
+      }
+    }
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function validateModelSettings(settings) {
+  return validateAgentSettings(settings);
+}
+function validateCustomModels(models) {
+  const validated = [];
+  for (const model of models) {
+    if (typeof model !== "object" || model === null) continue;
+    const m = model;
+    if (typeof m.id !== "string" || typeof m.name !== "string" || !isValidProvider(m.provider)) {
+      continue;
+    }
+    const customModel = {
+      id: m.id,
+      name: m.name,
+      provider: m.provider
+    };
+    if (typeof m.description === "string") {
+      customModel.description = m.description;
+    }
+    if (typeof m.capabilities === "object" && m.capabilities !== null) {
+      const caps = m.capabilities;
+      customModel.capabilities = {};
+      if (typeof caps.thinking === "boolean") {
+        customModel.capabilities.thinking = caps.thinking;
+      }
+      if (typeof caps.contextWindow === "number") {
+        customModel.capabilities.contextWindow = caps.contextWindow;
+      }
+      if (typeof caps.supportsTemperature === "boolean") {
+        customModel.capabilities.supportsTemperature = caps.supportsTemperature;
+      }
+    }
+    validated.push(customModel);
+  }
+  return validated.length > 0 ? validated : void 0;
+}
 function validateConfig(config) {
   const result = AthenaConfigSchema.safeParse(config);
   if (!result.success) {
@@ -1604,7 +1794,8 @@ function getDefaultConfig() {
     subscriptions: {
       claude: { enabled: false, tier: "none" },
       openai: { enabled: false },
-      google: { enabled: false, authMethod: "none" }
+      google: { enabled: false, authMethod: "none" },
+      githubCopilot: { enabled: false, plan: "none" }
     },
     models: {
       sisyphus: "anthropic/claude-sonnet-4",
@@ -1644,6 +1835,12 @@ function mergeConfigs(...configs) {
           ...config.subscriptions.google
         };
       }
+      if (config.subscriptions.githubCopilot) {
+        result.subscriptions.githubCopilot = {
+          ...result.subscriptions.githubCopilot,
+          ...config.subscriptions.githubCopilot
+        };
+      }
     }
     if (config.models) {
       result.models = { ...result.models, ...config.models };
@@ -1669,7 +1866,7 @@ var OpenCodeAthena = async (ctx) => {
   await tracker.initialize();
   const tools = createTools(ctx, tracker, config);
   const sessionHooks = createSessionHooks(ctx, tracker, config);
-  const toolHooks = createToolHooks();
+  const toolHooks = createToolHooks(tracker, config);
   const compactionHook = createCompactionHook(tracker);
   return {
     // Custom tools for BMAD integration