opencode-athena 0.0.1

package/dist/index.js

@@ -0,0 +1,1360 @@
+import { homedir, platform } from 'os';
+import { tool } from '@opencode-ai/plugin';
+import { join, dirname } from 'path';
+import { existsSync } from 'fs';
+import { readFile, mkdir, writeFile, rm } from 'fs/promises';
+import { parse, stringify } from 'yaml';
+import { z } from 'zod';
+
+// src/plugin/utils/notifications.ts
+async function sendNotification(message, title, $) {
+  const os = platform();
+  try {
+    if (os === "darwin") {
+      await $`osascript -e ${`display notification "${escapeAppleScript(message)}" with title "${escapeAppleScript(title)}"`}`;
+    } else if (os === "linux") {
+      await $`notify-send ${title} ${message}`;
+    } else {
+      logNotification(title, message);
+    }
+  } catch {
+    logNotification(title, message);
+  }
+}
+function escapeAppleScript(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function logNotification(title, message) {
+  console.log(`[${title}] ${message}`);
+}
+
+// src/plugin/hooks/session-hooks.ts
+function createSessionHooks(ctx, tracker, config) {
+  return async ({ event }) => {
+    const eventType = event.type;
+    switch (eventType) {
+      case "session.idle":
+        await handleSessionIdle(ctx, tracker, config);
+        break;
+      case "session.created":
+        handleSessionCreated(tracker);
+        break;
+      case "session.error":
+        handleSessionError(event, tracker);
+        break;
+    }
+  };
+}
+async function handleSessionIdle(ctx, tracker, config) {
+  const currentStory = tracker.getCurrentStory();
+  if (currentStory && currentStory.status === "in_progress") {
+    if (config.features?.notifications) {
+      await sendNotification(
+        `Story ${currentStory.id} in progress. Remember to update status when complete!`,
+        "OpenCode Athena",
+        ctx.$
+      );
+    }
+  }
+}
+function handleSessionCreated(tracker) {
+  const currentStory = tracker.getCurrentStory();
+  if (currentStory) {
+    console.log(`[Athena] Resuming with Story ${currentStory.id} (${currentStory.status})`);
+  }
+}
+function handleSessionError(event, tracker) {
+  const currentStory = tracker.getCurrentStory();
+  if (currentStory && event.error) {
+    console.error(`[Athena] Error during Story ${currentStory.id}:`, event.error);
+  }
+}
+
+// src/plugin/hooks/tool-hooks.ts
+function createToolHooks(_tracker, _config) {
+  return {
+    /**
+     * Called before a tool executes
+     * Can modify args or throw to block execution
+     */
+    before: async (_input, _output) => {
+    },
+    /**
+     * Called after a tool executes
+     * Can modify output or append messages
+     */
+    after: async (_input, _output) => {
+    }
+  };
+}
+
+// src/plugin/hooks/compaction-hook.ts
+function createCompactionHook(tracker) {
+  return async (_input, output) => {
+    const storyContext = await tracker.getCurrentStoryContext();
+    if (storyContext) {
+      output.context.push(`## OpenCode Athena - Current BMAD Story Context
+
+${storyContext}
+
+IMPORTANT: You are implementing a BMAD story. Use athena_get_story to reload full context if needed. Use athena_update_status to update the story status when complete.
+`);
+    }
+  };
+}
+var VERSION = "0.0.1";
+var PACKAGE_NAME = "opencode-athena";
+var DISPLAY_NAME = "OpenCode Athena";
+var CONFIG_PATHS = {
+  /** Global OpenCode config directory */
+  globalConfigDir: join(homedir(), ".config", "opencode"),
+  /** Global Athena config file */
+  globalAthenaConfig: join(homedir(), ".config", "opencode", "athena.json"),
+  /** Global OpenCode config file */
+  globalOpencodeConfig: join(homedir(), ".config", "opencode", "opencode.json"),
+  /** Global oh-my-opencode config file */
+  globalOmoConfig: join(homedir(), ".config", "opencode", "oh-my-opencode.json"),
+  /** Commands directory */
+  commandsDir: join(homedir(), ".config", "opencode", "command"),
+  /** Plugin directory */
+  pluginDir: join(homedir(), ".config", "opencode", "plugin"),
+  /** Athena state file (for story tracking) */
+  stateFile: join(homedir(), ".config", "opencode", "athena-state.json")
+};
+var PROJECT_PATHS = {
+  /** Local Athena config */
+  localConfig: ".opencode/athena.json",
+  /** BMAD directory */
+  bmadDir: "docs",
+  /** BMAD docs directory (deprecated - same as bmadDir in v6) */
+  bmadDocsDir: "docs",
+  /** Sprint status file */
+  sprintStatus: "docs/implementation-artifacts/sprint-status.yaml",
+  /** Stories directory */
+  storiesDir: "docs/implementation-artifacts/stories",
+  /** Architecture document */
+  architecture: "docs/project-planning-artifacts/architecture.md",
+  /** PRD document */
+  prd: "docs/project-planning-artifacts/PRD.md"
+};
+var DEFAULTS = {
+  /** Default BMAD track for new projects */
+  defaultTrack: "bmad-method",
+  /** Whether to auto-update sprint status */
+  autoStatusUpdate: true,
+  /** Maximum parallel stories */
+  parallelStoryLimit: 3,
+  /** Default features enabled */
+  features: {
+    bmadBridge: true,
+    autoStatus: true,
+    parallelExecution: true,
+    notifications: true,
+    contextMonitor: true,
+    commentChecker: true,
+    lspTools: true
+  },
+  /** Default MCPs enabled */
+  mcps: {
+    context7: true,
+    exa: true,
+    grepApp: true
+  }
+};
+
+// src/plugin/tools/config.ts
+function createConfigTool(config) {
+  return tool({
+    description: `View the current OpenCode Athena configuration.
+
+Shows:
+- Version information
+- Subscription settings (Claude, OpenAI, Google)
+- Model assignments for each agent role
+- BMAD integration settings
+- Enabled features and MCP servers`,
+    args: {
+      section: tool.schema.enum(["all", "subscriptions", "models", "bmad", "features", "mcps"]).optional().describe("Specific section to view (default: all)")
+    },
+    async execute(args) {
+      const section = args.section || "all";
+      if (section === "all") {
+        return JSON.stringify(
+          {
+            athenaVersion: VERSION,
+            configVersion: config.version,
+            subscriptions: config.subscriptions,
+            models: config.models,
+            bmad: config.bmad,
+            features: config.features,
+            mcps: config.mcps
+          },
+          null,
+          2
+        );
+      }
+      const sectionData = {
+        subscriptions: config.subscriptions,
+        models: config.models,
+        bmad: config.bmad,
+        features: config.features,
+        mcps: config.mcps
+      };
+      return JSON.stringify(
+        {
+          section,
+          data: sectionData[section] || null
+        },
+        null,
+        2
+      );
+    }
+  });
+}
+function createGetContextTool(tracker, _config) {
+  return tool({
+    description: `Get the current story context without reloading from files.
+
+Returns the cached context from the story tracker including:
+- Current story ID and status
+- When the story was started
+- Recent activity history
+
+Use this for quick status checks. Use athena_get_story to reload full context from files.`,
+    args: {},
+    async execute() {
+      const currentStory = tracker.getCurrentStory();
+      if (!currentStory) {
+        return JSON.stringify({
+          status: "no_active_story",
+          message: "No story is currently being tracked. Use athena_get_story to load a story."
+        });
+      }
+      const context = await tracker.getCurrentStoryContext();
+      const history = tracker.getHistory().slice(-10);
+      return JSON.stringify(
+        {
+          currentStory: {
+            id: currentStory.id,
+            status: currentStory.status,
+            startedAt: currentStory.startedAt,
+            completedAt: currentStory.completedAt
+          },
+          contextSummary: context,
+          recentHistory: history,
+          sessionId: tracker.getSessionId()
+        },
+        null,
+        2
+      );
+    }
+  });
+}
+var BMAD_DIR_NAMES = ["docs", ".bmad", "bmad"];
+var BMAD_V6_DEFAULTS = {
+  planningArtifacts: "docs/project-planning-artifacts",
+  implementationArtifacts: "docs/implementation-artifacts"};
+var LEGACY_PATHS = {
+  docsDir: "docs",
+  sprintArtifacts: "docs/sprint-artifacts"
+};
+async function findBmadDir(startDir) {
+  let currentDir = startDir;
+  const visited = /* @__PURE__ */ new Set();
+  while (currentDir && !visited.has(currentDir)) {
+    visited.add(currentDir);
+    for (const dirName of BMAD_DIR_NAMES) {
+      const bmadPath = join(currentDir, dirName);
+      if (existsSync(bmadPath)) {
+        return bmadPath;
+      }
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function readBmadConfig(bmadDir) {
+  const configPath = join(bmadDir, "bmm", "config.yaml");
+  if (!existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(configPath, "utf-8");
+    return parse(content);
+  } catch {
+    return null;
+  }
+}
+function searchForFile(projectRoot, filename, searchPaths) {
+  for (const searchPath of searchPaths) {
+    const fullPath = join(projectRoot, searchPath, filename);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return join(projectRoot, searchPaths[0], filename);
+}
+async function getBmadPaths(startDir) {
+  const bmadDir = await findBmadDir(startDir);
+  const projectRoot = bmadDir ? dirname(bmadDir) : startDir;
+  let config = null;
+  if (bmadDir) {
+    config = await readBmadConfig(bmadDir);
+  }
+  const planningDir = config?.planning_artifacts || join(projectRoot, BMAD_V6_DEFAULTS.planningArtifacts);
+  const implementationDir = config?.implementation_artifacts || config?.sprint_artifacts || join(projectRoot, BMAD_V6_DEFAULTS.implementationArtifacts);
+  const storiesDir = join(implementationDir, "stories");
+  const sprintStatusSearchPaths = [
+    config?.implementation_artifacts || BMAD_V6_DEFAULTS.implementationArtifacts,
+    config?.sprint_artifacts || "docs/sprint-artifacts",
+    LEGACY_PATHS.sprintArtifacts,
+    LEGACY_PATHS.docsDir
+  ];
+  const sprintStatus = searchForFile(projectRoot, "sprint-status.yaml", sprintStatusSearchPaths);
+  const architectureSearchPaths = [
+    config?.planning_artifacts || BMAD_V6_DEFAULTS.planningArtifacts,
+    LEGACY_PATHS.docsDir
+  ];
+  const architecture = searchForFile(projectRoot, "architecture.md", architectureSearchPaths);
+  const prdSearchPaths = [
+    config?.planning_artifacts || BMAD_V6_DEFAULTS.planningArtifacts,
+    LEGACY_PATHS.docsDir
+  ];
+  const prd = searchForFile(projectRoot, "PRD.md", prdSearchPaths);
+  const epicsSearchPaths = [
+    config?.planning_artifacts || BMAD_V6_DEFAULTS.planningArtifacts,
+    LEGACY_PATHS.docsDir
+  ];
+  const epics = searchForFile(projectRoot, "epics.md", epicsSearchPaths);
+  return {
+    projectRoot,
+    bmadDir,
+    planningDir,
+    implementationDir,
+    storiesDir,
+    sprintStatus,
+    architecture,
+    prd,
+    epics
+  };
+}
+async function extractRelevantArchitecture(archPath, storyContent) {
+  if (!existsSync(archPath)) {
+    return "";
+  }
+  try {
+    const archContent = await readFile(archPath, "utf-8");
+    const sections = [];
+    const techStackMatch = archContent.match(/## Tech(?:nology)? Stack[\s\S]*?(?=\n## |$)/i);
+    if (techStackMatch) {
+      sections.push(techStackMatch[0].trim());
+    }
+    const patternsMatch = archContent.match(
+      /## (?:Patterns|Conventions|Standards|Coding Standards)[\s\S]*?(?=\n## |$)/i
+    );
+    if (patternsMatch) {
+      sections.push(patternsMatch[0].trim());
+    }
+    if (/data|database|model|schema|entity/i.test(storyContent)) {
+      const dataMatch = archContent.match(
+        /## (?:Data Model|Database|Schema|Data Layer)[\s\S]*?(?=\n## |$)/i
+      );
+      if (dataMatch) {
+        sections.push(dataMatch[0].trim());
+      }
+    }
+    if (/api|endpoint|route|rest|graphql/i.test(storyContent)) {
+      const apiMatch = archContent.match(
+        /## (?:API|Endpoints|Routes|REST|GraphQL)[\s\S]*?(?=\n## |$)/i
+      );
+      if (apiMatch) {
+        sections.push(apiMatch[0].trim());
+      }
+    }
+    if (/ui|component|view|page|screen|frontend/i.test(storyContent)) {
+      const uiMatch = archContent.match(
+        /## (?:UI|Components|Views|Frontend|User Interface)[\s\S]*?(?=\n## |$)/i
+      );
+      if (uiMatch) {
+        sections.push(uiMatch[0].trim());
+      }
+    }
+    return sections.length > 0 ? sections.join("\n\n---\n\n") : "See full architecture document for details.";
+  } catch (error) {
+    console.warn("[Athena] Failed to read architecture file:", error);
+    return "";
+  }
+}
+async function extractRelevantPRD(prdPath, storyContent) {
+  if (!existsSync(prdPath)) {
+    return "";
+  }
+  try {
+    const prdContent = await readFile(prdPath, "utf-8");
+    const frMatches = storyContent.match(/FR-?\d+/gi);
+    if (!frMatches || frMatches.length === 0) {
+      return "";
+    }
+    const uniqueFRs = [...new Set(frMatches.map((fr) => fr.toUpperCase()))];
+    const sections = [];
+    for (const fr of uniqueFRs) {
+      const normalizedFR = fr.replace("-", "-?");
+      const regex = new RegExp(`###+ ${normalizedFR}[:\\s][\\s\\S]*?(?=\\n###+ |$)`, "i");
+      const match = prdContent.match(regex);
+      if (match) {
+        sections.push(match[0].trim());
+      }
+    }
+    return sections.join("\n\n");
+  } catch (error) {
+    console.warn("[Athena] Failed to read PRD file:", error);
+    return "";
+  }
+}
+function generateImplementationInstructions(storyId) {
+  return `
+## Implementation Instructions for Story ${storyId}
+
+You are implementing this story using OpenCode Athena's full capabilities.
+
+### Available Subagents
+- **@oracle** - Use for complex debugging, architectural decisions, or strategic code choices
+- **@librarian** - Use for finding implementation examples, researching patterns, exploring documentation
+- **@explore** - Use for fast codebase searches and pattern matching
+- **@frontend-ui-ux-engineer** - Use for UI component implementation (if applicable)
+
+### Available Tools
+- **LSP Tools** - Use lsp_rename, lsp_find_references, lsp_code_actions for refactoring
+- **AST-Grep** - Use ast_grep_search and ast_grep_replace for structural code changes
+
+### Quality Standards
+1. Meet ALL acceptance criteria listed in the story
+2. Follow architecture patterns exactly as specified
+3. Keep comments minimal - code should be self-documenting
+4. Run tests before marking complete
+5. Ensure no regressions in existing functionality
+
+### Completion
+When implementation is complete:
+1. Call **athena_update_status** with status "completed" and a completion summary
+2. The sprint-status.yaml will be automatically updated
+3. Report what was implemented and any decisions made
+
+### If You Get Stuck
+- Call @oracle for debugging help
+- Call @librarian to find similar implementations
+- Check the architecture document for patterns
+`.trim();
+}
+var LOCK_EXT = ".lock";
+var LOCK_TIMEOUT = 1e4;
+var LOCK_RETRY_INTERVAL = 50;
+var STALE_LOCK_AGE = 3e4;
+async function acquireLock(filePath) {
+  const lockPath = `${filePath}${LOCK_EXT}`;
+  const startTime = Date.now();
+  const lockId = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  while (Date.now() - startTime < LOCK_TIMEOUT) {
+    try {
+      if (existsSync(lockPath)) {
+        const lockContent = await readFile(lockPath, "utf-8").catch(() => null);
+        if (lockContent) {
+          try {
+            const lockData2 = JSON.parse(lockContent);
+            const lockAge = Date.now() - lockData2.timestamp;
+            if (lockAge > STALE_LOCK_AGE) {
+              await rm(lockPath, { force: true });
+            }
+          } catch {
+            await rm(lockPath, { force: true });
+          }
+        }
+      }
+      const lockData = JSON.stringify({
+        id: lockId,
+        pid: process.pid,
+        timestamp: Date.now()
+      });
+      await writeFile(lockPath, lockData, { flag: "wx" });
+      return async () => {
+        try {
+          const currentContent = await readFile(lockPath, "utf-8").catch(() => null);
+          if (currentContent) {
+            const currentData = JSON.parse(currentContent);
+            if (currentData.id === lockId) {
+              await rm(lockPath, { force: true });
+            }
+          }
+        } catch {
+        }
+      };
+    } catch (error) {
+      const nodeError = error;
+      if (nodeError.code !== "EEXIST") {
+        throw error;
+      }
+      await sleep(LOCK_RETRY_INTERVAL);
+    }
+  }
+  throw new Error(`Failed to acquire lock for ${filePath} within ${LOCK_TIMEOUT}ms`);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function readYamlFile(filePath) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(filePath, "utf-8");
+    return parse(content);
+  } catch (error) {
+    console.warn(`[Athena] Failed to parse YAML file ${filePath}:`, error);
+    return null;
+  }
+}
+async function writeYamlFile(filePath, data) {
+  const content = stringify(data, {
+    indent: 2,
+    lineWidth: 120
+  });
+  await writeFile(filePath, content, "utf-8");
+}
+async function readSprintStatus(filePath) {
+  const raw = await readYamlFile(filePath);
+  if (!raw) {
+    return null;
+  }
+  return {
+    completed_stories: [],
+    pending_stories: [],
+    in_progress_stories: [],
+    blocked_stories: [],
+    ...raw
+  };
+}
+async function writeSprintStatus(filePath, status) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  const releaseLock = await acquireLock(filePath);
+  try {
+    const currentStatus = await readSprintStatus(filePath);
+    let statusToWrite = status;
+    if (currentStatus) {
+      if (status.last_modified && currentStatus.last_modified && currentStatus.last_modified !== status.last_modified) {
+        statusToWrite = mergeSprintStatus(currentStatus, status);
+      }
+    }
+    statusToWrite.last_modified = (/* @__PURE__ */ new Date()).toISOString();
+    await writeYamlFile(filePath, statusToWrite);
+  } finally {
+    await releaseLock();
+  }
+}
+function mergeSprintStatus(current, incoming) {
+  const merged = { ...current };
+  merged.story_updates = { ...current.story_updates };
+  if (incoming.story_updates) {
+    for (const [storyId, update] of Object.entries(incoming.story_updates)) {
+      const currentUpdate = merged.story_updates?.[storyId];
+      if (!currentUpdate || new Date(update.updated_at) > new Date(currentUpdate.updated_at)) {
+        merged.story_updates = merged.story_updates || {};
+        merged.story_updates[storyId] = update;
+      }
+    }
+  }
+  if (merged.story_updates) {
+    const statusArrays = {
+      completed_stories: /* @__PURE__ */ new Set(),
+      pending_stories: /* @__PURE__ */ new Set(),
+      in_progress_stories: /* @__PURE__ */ new Set(),
+      blocked_stories: /* @__PURE__ */ new Set(),
+      stories_needing_review: /* @__PURE__ */ new Set()
+    };
+    for (const story of current.completed_stories || []) {
+      statusArrays.completed_stories.add(story);
+    }
+    for (const story of current.pending_stories || []) {
+      statusArrays.pending_stories.add(story);
+    }
+    for (const story of current.in_progress_stories || []) {
+      statusArrays.in_progress_stories.add(story);
+    }
+    for (const story of current.blocked_stories || []) {
+      statusArrays.blocked_stories.add(story);
+    }
+    for (const [storyId, update] of Object.entries(merged.story_updates)) {
+      statusArrays.completed_stories.delete(storyId);
+      statusArrays.pending_stories.delete(storyId);
+      statusArrays.in_progress_stories.delete(storyId);
+      statusArrays.blocked_stories.delete(storyId);
+      statusArrays.stories_needing_review.delete(storyId);
+      switch (update.status) {
+        case "completed":
+          statusArrays.completed_stories.add(storyId);
+          break;
+        case "pending":
+          statusArrays.pending_stories.add(storyId);
+          break;
+        case "in_progress":
+          statusArrays.in_progress_stories.add(storyId);
+          break;
+        case "blocked":
+          statusArrays.blocked_stories.add(storyId);
+          break;
+        case "needs_review":
+          statusArrays.in_progress_stories.add(storyId);
+          statusArrays.stories_needing_review.add(storyId);
+          break;
+      }
+    }
+    merged.completed_stories = [...statusArrays.completed_stories];
+    merged.pending_stories = [...statusArrays.pending_stories];
+    merged.in_progress_stories = [...statusArrays.in_progress_stories];
+    merged.blocked_stories = [...statusArrays.blocked_stories];
+    merged.stories_needing_review = [...statusArrays.stories_needing_review];
+  }
+  if (incoming.current_story !== void 0) {
+    merged.current_story = incoming.current_story;
+  }
+  return merged;
+}
+
+// src/plugin/tools/get-story.ts
+function createGetStoryTool(ctx, tracker, _config) {
+  return tool({
+    description: `Load the current BMAD story context for implementation.
+
+Returns:
+- Story file content with requirements and acceptance criteria
+- Relevant architecture sections
+- Sprint progress information
+- Implementation instructions for using Sisyphus and subagents
+
+Use this tool before starting story implementation to get full context.`,
+    args: {
+      storyId: tool.schema.string().optional().describe(
+        "Specific story ID (e.g., '2.3'). If omitted, loads the next pending story from sprint-status.yaml."
+      )
+    },
+    async execute(args) {
+      const result = await getStoryContext(ctx, tracker, args.storyId);
+      return JSON.stringify(result, null, 2);
+    }
+  });
+}
+async function getStoryContext(ctx, tracker, requestedStoryId) {
+  const paths = await getBmadPaths(ctx.directory);
+  if (!paths.bmadDir) {
+    return {
+      error: "No BMAD directory found",
+      suggestion: "Run 'npx bmad-method@alpha install' to set up BMAD in this project."
+    };
+  }
+  const sprint = await readSprintStatus(paths.sprintStatus);
+  if (!sprint) {
+    return {
+      error: "No sprint-status.yaml found",
+      suggestion: "Run the sprint-planning workflow with BMAD's SM agent first."
+    };
+  }
+  const storyId = requestedStoryId || findNextPendingStory(sprint);
+  if (!storyId) {
+    return {
+      error: "No pending stories found",
+      sprintProgress: {
+        completed: sprint.completed_stories.length,
+        total: sprint.completed_stories.length + sprint.pending_stories.length + sprint.in_progress_stories.length
+      },
+      suggestion: "All stories in current sprint are complete!"
+    };
+  }
+  const storyContent = await loadStoryFile(paths.storiesDir, storyId);
+  if (!storyContent) {
+    return {
+      error: `Story file not found for ${storyId}`,
+      suggestion: "Run 'create-story' workflow with BMAD's SM agent."
+    };
+  }
+  const archContent = await extractRelevantArchitecture(paths.architecture, storyContent);
+  const prdContent = await extractRelevantPRD(paths.prd, storyContent);
+  await tracker.setCurrentStory(storyId, {
+    content: storyContent,
+    status: "loading",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return {
+    storyId,
+    story: storyContent,
+    architecture: archContent || "No architecture document found.",
+    prd: prdContent || "No PRD document found.",
+    sprint: {
+      currentEpic: sprint.current_epic || "Unknown",
+      completedStories: sprint.completed_stories.length,
+      pendingStories: sprint.pending_stories.length,
+      blockedStories: sprint.blocked_stories.length
+    },
+    instructions: generateImplementationInstructions(storyId)
+  };
+}
+function findNextPendingStory(sprint) {
+  if (sprint.current_story) {
+    return sprint.current_story;
+  }
+  if (sprint.in_progress_stories.length > 0) {
+    return sprint.in_progress_stories[0];
+  }
+  if (sprint.pending_stories.length > 0) {
+    return sprint.pending_stories[0];
+  }
+  return null;
+}
+async function loadStoryFile(storiesDir, storyId) {
+  const possibleNames = [
+    `story-${storyId.replace(".", "-")}.md`,
+    // story-2-3.md
+    `story-${storyId}.md`,
+    // story-2.3.md
+    `${storyId}.md`
+    // 2.3.md
+  ];
+  for (const fileName of possibleNames) {
+    const filePath = join(storiesDir, fileName);
+    if (existsSync(filePath)) {
+      try {
+        return await readFile(filePath, "utf-8");
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function createParallelTool() {
+  return tool({
+    description: `Execute multiple independent stories in parallel using background agents.
+
+NOTE: This feature is not yet implemented. It requires integration with oh-my-opencode's background agent system.
+
+When implemented, this tool will:
+1. Validate that the specified stories have no file conflicts
+2. Mark all stories as in_progress in sprint-status.yaml
+3. Spawn background agents to implement each story
+4. Coordinate completion and report results`,
+    args: {
+      storyIds: tool.schema.array(tool.schema.string()).describe("Array of story IDs to execute in parallel"),
+      waitForCompletion: tool.schema.boolean().optional().describe("Whether to wait for all stories to complete (default: true)")
+    },
+    async execute(args) {
+      return JSON.stringify(
+        {
+          error: "Not implemented",
+          message: "Parallel story execution is not yet implemented. This feature requires integration with oh-my-opencode's background agent system.",
+          requestedStories: args.storyIds,
+          suggestion: "For now, implement stories sequentially using /athena-dev for each story."
+        },
+        null,
+        2
+      );
+    }
+  });
+}
+function createUpdateStatusTool(ctx, tracker, config) {
+  return tool({
+    description: `Update the BMAD sprint status for a story.
+
+Call this tool when:
+- Starting a story (status: "in_progress")
+- Completing a story (status: "completed") - requires completionSummary
+- Blocking on an issue (status: "blocked") - requires notes explaining blocker
+- Requesting review (status: "needs_review")
+
+The sprint-status.yaml file will be automatically updated.`,
+    args: {
+      storyId: tool.schema.string().describe("The story ID (e.g., '2.3')"),
+      status: tool.schema.enum(["in_progress", "completed", "blocked", "needs_review"]).describe("The new status for the story"),
+      notes: tool.schema.string().optional().describe("Notes about the status change (required for 'blocked' status)"),
+      completionSummary: tool.schema.string().optional().describe("Summary of what was implemented (required for 'completed' status)")
+    },
+    async execute(args) {
+      const result = await updateStoryStatus(ctx, tracker, config, args);
+      return JSON.stringify(result, null, 2);
+    }
+  });
+}
+async function updateStoryStatus(ctx, tracker, config, args) {
+  const { storyId, status, notes, completionSummary } = args;
+  if (status === "completed" && !completionSummary) {
+    return {
+      error: "completionSummary is required when marking a story completed"
+    };
+  }
+  if (status === "blocked" && !notes) {
+    return {
+      error: "notes are required when blocking a story (explain the blocker)"
+    };
+  }
+  const paths = await getBmadPaths(ctx.directory);
+  if (!paths.bmadDir) {
+    return { error: "No BMAD directory found" };
+  }
+  if (!existsSync(paths.sprintStatus)) {
+    return { error: "No sprint-status.yaml found" };
+  }
+  const sprint = await readSprintStatus(paths.sprintStatus);
+  if (!sprint) {
+    return { error: "Failed to read sprint-status.yaml" };
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  removeFromAllArrays(sprint, storyId);
+  switch (status) {
+    case "in_progress":
+      addToArrayIfNotPresent(sprint.in_progress_stories, storyId);
+      sprint.current_story = storyId;
+      break;
+    case "completed":
+      addToArrayIfNotPresent(sprint.completed_stories, storyId);
+      if (sprint.current_story === storyId) {
+        sprint.current_story = null;
+      }
+      break;
+    case "blocked":
+      addToArrayIfNotPresent(sprint.blocked_stories, storyId);
+      if (sprint.current_story === storyId) {
+        sprint.current_story = null;
+      }
+      break;
+    case "needs_review":
+      addToArrayIfNotPresent(sprint.in_progress_stories, storyId);
+      sprint.stories_needing_review = sprint.stories_needing_review || [];
+      addToArrayIfNotPresent(sprint.stories_needing_review, storyId);
+      break;
+  }
+  sprint.story_updates = sprint.story_updates || {};
+  sprint.story_updates[storyId] = {
+    status,
+    updated_at: now,
+    ...notes && { notes },
+    ...completionSummary && { completion_summary: completionSummary }
+  };
+  await writeSprintStatus(paths.sprintStatus, sprint);
+  await tracker.updateStoryStatus(storyId, status);
+  if (config.features?.notifications && status === "completed") {
+    await sendNotification(`Story ${storyId} completed!`, "OpenCode Athena", ctx.$);
+  }
+  const totalStories = sprint.completed_stories.length + sprint.pending_stories.length + sprint.in_progress_stories.length + sprint.blocked_stories.length;
+  const percentComplete = totalStories > 0 ? Math.round(sprint.completed_stories.length / totalStories * 100) : 0;
+  return {
+    success: true,
+    storyId,
+    newStatus: status,
+    updatedAt: now,
+    sprintProgress: {
+      completed: sprint.completed_stories.length,
+      inProgress: sprint.in_progress_stories.length,
+      pending: sprint.pending_stories.length,
+      blocked: sprint.blocked_stories.length,
+      total: totalStories,
+      percentComplete
+    },
+    nextStory: status === "completed" ? sprint.pending_stories[0] || null : null
+  };
+}
+function removeFromAllArrays(sprint, storyId) {
+  sprint.completed_stories = [...new Set(sprint.completed_stories.filter((s) => s !== storyId))];
+  sprint.pending_stories = [...new Set(sprint.pending_stories.filter((s) => s !== storyId))];
+  sprint.in_progress_stories = [
+    ...new Set(sprint.in_progress_stories.filter((s) => s !== storyId))
+  ];
+  sprint.blocked_stories = [...new Set(sprint.blocked_stories.filter((s) => s !== storyId))];
+  if (sprint.stories_needing_review) {
+    sprint.stories_needing_review = [
+      ...new Set(sprint.stories_needing_review.filter((s) => s !== storyId))
+    ];
+  }
+}
+function addToArrayIfNotPresent(array, storyId) {
+  if (!array.includes(storyId)) {
+    array.push(storyId);
+  }
+}
+
+// src/plugin/tools/index.ts
+function createTools(ctx, tracker, config) {
+  return {
+    athena_get_story: createGetStoryTool(ctx, tracker),
+    athena_update_status: createUpdateStatusTool(ctx, tracker, config),
+    athena_get_context: createGetContextTool(tracker),
+    athena_parallel: createParallelTool(),
+    athena_config: createConfigTool(config)
+  };
+}
+var StoryTracker = class {
+  state;
+  stateFilePath;
+  projectDir;
+  constructor(projectDir) {
+    this.projectDir = projectDir;
+    this.stateFilePath = CONFIG_PATHS.stateFile;
+    this.state = {
+      currentStory: null,
+      sessionId: crypto.randomUUID(),
+      projectDir,
+      history: []
+    };
+  }
+  /**
+   * Initialize the tracker by loading existing state
+   */
+  async initialize() {
+    if (existsSync(this.stateFilePath)) {
+      try {
+        const content = await readFile(this.stateFilePath, "utf-8");
+        const savedState = JSON.parse(content);
+        if (savedState.projectDir === this.projectDir) {
+          this.state = {
+            ...savedState,
+            sessionId: crypto.randomUUID()
+            // Always generate new session ID
+          };
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Set the current story being worked on
+   */
+  async setCurrentStory(storyId, data) {
+    this.state.currentStory = { id: storyId, ...data };
+    this.addHistoryEntry(storyId, data.status);
+    await this.saveState();
+  }
+  /**
+   * Update the status of a story
+   */
+  async updateStoryStatus(storyId, status) {
+    if (this.state.currentStory?.id === storyId) {
+      this.state.currentStory.status = status;
+      if (status === "completed") {
+        this.state.currentStory.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    }
+    this.addHistoryEntry(storyId, status);
+    await this.saveState();
+  }
+  /**
+   * Get the current story being tracked
+   */
+  getCurrentStory() {
+    return this.state.currentStory;
+  }
+  /**
+   * Get a formatted context string for the current story
+   * Used for compaction hooks to preserve context
+   */
+  async getCurrentStoryContext() {
+    if (!this.state.currentStory) {
+      return null;
+    }
+    const story = this.state.currentStory;
+    const recentHistory = this.state.history.slice(-5).map((h) => `- ${h.storyId}: ${h.status} at ${h.timestamp}`).join("\n");
+    return `
+Current Story: ${story.id}
+Status: ${story.status}
+Started: ${story.startedAt}
+${story.completedAt ? `Completed: ${story.completedAt}` : ""}
+
+Recent Activity:
+${recentHistory}
+`.trim();
+  }
+  /**
+   * Clear the current story (e.g., when completed or cancelled)
+   */
+  async clearCurrentStory() {
+    this.state.currentStory = null;
+    await this.saveState();
+  }
+  /**
+   * Get the current session ID
+   */
+  getSessionId() {
+    return this.state.sessionId;
+  }
+  /**
+   * Get the history of status changes
+   */
+  getHistory() {
+    return this.state.history;
+  }
+  /**
+   * Add an entry to the history
+   */
+  addHistoryEntry(storyId, status) {
+    this.state.history.push({
+      storyId,
+      status,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (this.state.history.length > 100) {
+      this.state.history = this.state.history.slice(-100);
+    }
+  }
+  /**
+   * Save state to disk
+   */
+  async saveState() {
+    try {
+      const dir = dirname(this.stateFilePath);
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+      }
+      await writeFile(this.stateFilePath, JSON.stringify(this.state, null, 2), "utf-8");
+    } catch (error) {
+      console.warn("[Athena] Failed to save tracker state:", error);
+    }
+  }
+};
+var SubscriptionSchema = z.object({
+  claude: z.object({
+    enabled: z.boolean(),
+    tier: z.enum(["max5x", "max20x", "pro", "none"])
+  }),
+  openai: z.object({
+    enabled: z.boolean()
+  }),
+  google: z.object({
+    enabled: z.boolean(),
+    authMethod: z.enum(["antigravity", "personal", "api", "none"])
+  })
+});
+var BmadConfigSchema = z.object({
+  defaultTrack: z.enum(["quick-flow", "bmad-method", "enterprise"]),
+  autoStatusUpdate: z.boolean(),
+  parallelStoryLimit: z.number().int().min(0).max(10)
+});
+var FeaturesSchema = z.object({
+  bmadBridge: z.boolean(),
+  autoStatus: z.boolean(),
+  parallelExecution: z.boolean(),
+  notifications: z.boolean(),
+  contextMonitor: z.boolean(),
+  commentChecker: z.boolean(),
+  lspTools: z.boolean()
+});
+var McpsSchema = z.object({
+  context7: z.boolean(),
+  exa: z.boolean(),
+  grepApp: z.boolean()
+});
+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")
+});
+var AthenaConfigSchema = z.object({
+  $schema: z.string().optional(),
+  version: z.string(),
+  subscriptions: SubscriptionSchema,
+  models: ModelsSchema,
+  bmad: BmadConfigSchema,
+  features: FeaturesSchema,
+  mcps: McpsSchema
+});
+var GetStoryArgsSchema = z.object({
+  storyId: z.string().optional().describe(
+    "Specific story ID (e.g., '2.3'). If omitted, loads the next pending story from sprint-status.yaml."
+  )
+});
+var UpdateStatusArgsSchema = z.object({
+  storyId: z.string().describe("The story ID (e.g., '2.3')"),
+  status: z.enum(["in_progress", "completed", "blocked", "needs_review"]).describe("The new status for the story"),
+  notes: z.string().optional().describe("Notes about the status change (required for 'blocked' status)"),
+  completionSummary: z.string().optional().describe("Summary of what was implemented (required for 'completed' status)")
+});
+z.object({
+  includeArchitecture: z.boolean().optional().default(true),
+  includePrd: z.boolean().optional().default(false),
+  includeSprintStatus: z.boolean().optional().default(true)
+});
+z.object({
+  storyIds: z.array(z.string()).describe("Array of story IDs to implement in parallel"),
+  maxConcurrent: z.number().int().min(1).max(5).optional().default(3)
+});
+z.object({
+  action: z.enum(["get", "set", "reset"]).describe("Configuration action to perform"),
+  key: z.string().optional().describe("Configuration key (dot notation, e.g., 'bmad.autoStatusUpdate')"),
+  value: z.unknown().optional().describe("Value to set (for 'set' action)")
+});
+var StoryStatusEnum = z.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "blocked",
+  "needs_review"
+]);
+var TrackerStatusEnum = z.enum([
+  "pending",
+  "in_progress",
+  "completed",
+  "blocked",
+  "needs_review",
+  "loading"
+]);
+var SprintStatusSchema = z.object({
+  sprint_number: z.number().int().optional(),
+  current_epic: z.string().optional(),
+  current_story: z.string().nullable().optional(),
+  completed_stories: z.array(z.string()).default([]),
+  pending_stories: z.array(z.string()).default([]),
+  in_progress_stories: z.array(z.string()).default([]),
+  blocked_stories: z.array(z.string()).default([]),
+  stories_needing_review: z.array(z.string()).optional(),
+  story_updates: z.record(
+    z.object({
+      status: StoryStatusEnum,
+      updated_at: z.string(),
+      notes: z.string().optional(),
+      completion_summary: z.string().optional()
+    })
+  ).optional(),
+  last_modified: z.string().optional()
+});
+
+// src/plugin/utils/config-loader.ts
+async function loadAthenaConfig(projectDir) {
+  const localConfigPath = join(projectDir, ".opencode", "athena.json");
+  const localConfig = await loadConfigFile(localConfigPath);
+  const globalConfig = await loadConfigFile(CONFIG_PATHS.globalAthenaConfig);
+  const merged = mergeConfigs(getDefaultConfig(), globalConfig, localConfig);
+  return validateConfig(merged);
+}
+async function loadConfigFile(filePath) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return validatePartialConfig(parsed, filePath);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      console.warn(`[Athena] Invalid JSON in config file ${filePath}:`, error.message);
+    } else {
+      console.warn(`[Athena] Failed to load config from ${filePath}:`, error);
+    }
+    return null;
+  }
+}
+function validatePartialConfig(config, filePath) {
+  if (typeof config !== "object" || config === null) {
+    console.warn(`[Athena] Config file ${filePath} must be an object`);
+    return null;
+  }
+  const result = {};
+  const configObj = config;
+  if ("version" in configObj && typeof configObj.version === "string") {
+    result.version = configObj.version;
+  }
+  if ("$schema" in configObj && typeof configObj.$schema === "string") {
+    result.$schema = configObj.$schema;
+  }
+  if ("subscriptions" in configObj && typeof configObj.subscriptions === "object") {
+    const subs = configObj.subscriptions;
+    result.subscriptions = {};
+    if (subs.claude && typeof subs.claude === "object") {
+      const claude = subs.claude;
+      result.subscriptions.claude = {
+        enabled: typeof claude.enabled === "boolean" ? claude.enabled : false,
+        tier: isValidTier(claude.tier) ? claude.tier : "none"
+      };
+    }
+    if (subs.openai && typeof subs.openai === "object") {
+      const openai = subs.openai;
+      result.subscriptions.openai = {
+        enabled: typeof openai.enabled === "boolean" ? openai.enabled : false
+      };
+    }
+    if (subs.google && typeof subs.google === "object") {
+      const google = subs.google;
+      result.subscriptions.google = {
+        enabled: typeof google.enabled === "boolean" ? google.enabled : false,
+        authMethod: isValidAuthMethod(google.authMethod) ? google.authMethod : "none"
+      };
+    }
+  }
+  if ("models" in configObj && typeof configObj.models === "object") {
+    const models = configObj.models;
+    result.models = {};
+    for (const key of [
+      "sisyphus",
+      "oracle",
+      "librarian",
+      "frontend",
+      "documentWriter",
+      "multimodalLooker"
+    ]) {
+      if (key in models && typeof models[key] === "string") {
+        result.models[key] = models[key];
+      }
+    }
+  }
+  if ("bmad" in configObj && typeof configObj.bmad === "object") {
+    const bmad = configObj.bmad;
+    result.bmad = {};
+    if (isValidTrack(bmad.defaultTrack)) {
+      result.bmad.defaultTrack = bmad.defaultTrack;
+    }
+    if (typeof bmad.autoStatusUpdate === "boolean") {
+      result.bmad.autoStatusUpdate = bmad.autoStatusUpdate;
+    }
+    if (typeof bmad.parallelStoryLimit === "number") {
+      result.bmad.parallelStoryLimit = Math.max(0, Math.min(10, bmad.parallelStoryLimit));
+    }
+  }
+  if ("features" in configObj && typeof configObj.features === "object") {
+    const features = configObj.features;
+    result.features = {};
+    for (const key of [
+      "bmadBridge",
+      "autoStatus",
+      "parallelExecution",
+      "notifications",
+      "contextMonitor",
+      "commentChecker",
+      "lspTools"
+    ]) {
+      if (key in features && typeof features[key] === "boolean") {
+        result.features[key] = features[key];
+      }
+    }
+  }
+  if ("mcps" in configObj && typeof configObj.mcps === "object") {
+    const mcps = configObj.mcps;
+    result.mcps = {};
+    for (const key of ["context7", "exa", "grepApp"]) {
+      if (key in mcps && typeof mcps[key] === "boolean") {
+        result.mcps[key] = mcps[key];
+      }
+    }
+  }
+  return result;
+}
+function isValidTier(value) {
+  return typeof value === "string" && ["max5x", "max20x", "pro", "none"].includes(value);
+}
+function isValidAuthMethod(value) {
+  return typeof value === "string" && ["antigravity", "personal", "api", "none"].includes(value);
+}
+function isValidTrack(value) {
+  return typeof value === "string" && ["quick-flow", "bmad-method", "enterprise"].includes(value);
+}
+function validateConfig(config) {
+  const result = AthenaConfigSchema.safeParse(config);
+  if (!result.success) {
+    console.warn("[Athena] Configuration validation warnings:");
+    for (const error of result.error.errors) {
+      console.warn(`  - ${error.path.join(".")}: ${error.message}`);
+    }
+    return config;
+  }
+  return result.data;
+}
+function getDefaultConfig() {
+  return {
+    version: "0.0.1",
+    subscriptions: {
+      claude: { enabled: false, tier: "none" },
+      openai: { enabled: false },
+      google: { enabled: false, authMethod: "none" }
+    },
+    models: {
+      sisyphus: "anthropic/claude-sonnet-4",
+      oracle: "anthropic/claude-sonnet-4",
+      librarian: "anthropic/claude-sonnet-4"
+    },
+    bmad: {
+      defaultTrack: DEFAULTS.defaultTrack,
+      autoStatusUpdate: DEFAULTS.autoStatusUpdate,
+      parallelStoryLimit: DEFAULTS.parallelStoryLimit
+    },
+    features: { ...DEFAULTS.features },
+    mcps: { ...DEFAULTS.mcps }
+  };
+}
+function mergeConfigs(...configs) {
+  const result = getDefaultConfig();
+  for (const config of configs) {
+    if (!config) continue;
+    if (config.version) result.version = config.version;
+    if (config.subscriptions) {
+      if (config.subscriptions.claude) {
+        result.subscriptions.claude = {
+          ...result.subscriptions.claude,
+          ...config.subscriptions.claude
+        };
+      }
+      if (config.subscriptions.openai) {
+        result.subscriptions.openai = {
+          ...result.subscriptions.openai,
+          ...config.subscriptions.openai
+        };
+      }
+      if (config.subscriptions.google) {
+        result.subscriptions.google = {
+          ...result.subscriptions.google,
+          ...config.subscriptions.google
+        };
+      }
+    }
+    if (config.models) {
+      result.models = { ...result.models, ...config.models };
+    }
+    if (config.bmad) {
+      result.bmad = { ...result.bmad, ...config.bmad };
+    }
+    if (config.features) {
+      result.features = { ...result.features, ...config.features };
+    }
+    if (config.mcps) {
+      result.mcps = { ...result.mcps, ...config.mcps };
+    }
+  }
+  return result;
+}
+
+// src/plugin/index.ts
+var OpenCodeAthena = async (ctx) => {
+  const { directory } = ctx;
+  const config = await loadAthenaConfig(directory);
+  const tracker = new StoryTracker(directory);
+  await tracker.initialize();
+  const tools = createTools(ctx, tracker, config);
+  const sessionHooks = createSessionHooks(ctx, tracker, config);
+  const toolHooks = createToolHooks();
+  const compactionHook = createCompactionHook(tracker);
+  return {
+    // Custom tools for BMAD integration
+    tool: tools,
+    // Session event handlers
+    event: sessionHooks,
+    // Tool execution hooks (stubs for now)
+    "tool.execute.before": toolHooks.before,
+    "tool.execute.after": toolHooks.after,
+    // Compaction hook to preserve BMAD context
+    "experimental.session.compacting": compactionHook
+  };
+};
+
+export { AthenaConfigSchema, CONFIG_PATHS, DEFAULTS, DISPLAY_NAME, GetStoryArgsSchema, OpenCodeAthena, PACKAGE_NAME, PROJECT_PATHS, SprintStatusSchema, StoryStatusEnum, TrackerStatusEnum, UpdateStatusArgsSchema, VERSION, OpenCodeAthena as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map