homer-simpson 0.1.0

package/dist/features/claude-code-session-state/state.d.ts

@@ -0,0 +1,4 @@
+export declare const subagentSessions: Set<string>;
+export declare let mainSessionID: string | undefined;
+export declare function setMainSession(id: string | undefined): void;
+export declare function getMainSessionID(): string | undefined;

package/dist/features/context-injector/collector.d.ts

@@ -0,0 +1,11 @@
+import type { PendingContext, RegisterContextOptions } from "./types";
+export declare class ContextCollector {
+    private sessions;
+    register(sessionID: string, options: RegisterContextOptions): void;
+    getPending(sessionID: string): PendingContext;
+    consume(sessionID: string): PendingContext;
+    clear(sessionID: string): void;
+    hasPending(sessionID: string): boolean;
+    private sortEntries;
+}
+export declare const contextCollector: ContextCollector;

package/dist/features/context-injector/collector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/context-injector/index.d.ts

@@ -0,0 +1,3 @@
+export { ContextCollector, contextCollector } from "./collector";
+export { injectPendingContext, createContextInjectorHook, createContextInjectorMessagesTransformHook, } from "./injector";
+export type { ContextSourceType, ContextPriority, ContextEntry, RegisterContextOptions, PendingContext, MessageContext, OutputParts, InjectionStrategy, } from "./types";

package/dist/features/context-injector/injector.d.ts

@@ -0,0 +1,39 @@
+import type { ContextCollector } from "./collector";
+import type { Message, Part } from "@opencode-ai/sdk";
+interface OutputPart {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+}
+interface InjectionResult {
+    injected: boolean;
+    contextLength: number;
+}
+export declare function injectPendingContext(collector: ContextCollector, sessionID: string, parts: OutputPart[]): InjectionResult;
+interface ChatMessageInput {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    messageID?: string;
+}
+interface ChatMessageOutput {
+    message: Record<string, unknown>;
+    parts: OutputPart[];
+}
+export declare function createContextInjectorHook(collector: ContextCollector): {
+    "chat.message": (input: ChatMessageInput, output: ChatMessageOutput) => Promise<void>;
+};
+interface MessageWithParts {
+    info: Message;
+    parts: Part[];
+}
+type MessagesTransformHook = {
+    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+export declare function createContextInjectorMessagesTransformHook(collector: ContextCollector): MessagesTransformHook;
+export {};

package/dist/features/context-injector/injector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/context-injector/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Source identifier for context injection
+ * Each source registers context that will be merged and injected together
+ */
+export type ContextSourceType = "keyword-detector" | "rules-injector" | "directory-agents" | "directory-readme" | "spec-system" | "status-recorder" | "custom";
+/**
+ * Priority levels for context ordering
+ * Higher priority contexts appear first in the merged output
+ */
+export type ContextPriority = "critical" | "high" | "medium" | "normal" | "low";
+/**
+ * A single context entry registered by a source
+ */
+export interface ContextEntry {
+    /** Unique identifier for this entry within the source */
+    id: string;
+    /** The source that registered this context */
+    source: ContextSourceType;
+    /** The actual context content to inject */
+    content: string;
+    /** Priority for ordering (default: normal) */
+    priority: ContextPriority;
+    /** Timestamp when registered */
+    timestamp: number;
+    /** Optional metadata for debugging/logging */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for registering context
+ */
+export interface RegisterContextOptions {
+    /** Unique ID for this context entry (used for deduplication) */
+    id: string;
+    /** Source identifier */
+    source: ContextSourceType;
+    /** The content to inject */
+    content: string;
+    /** Priority for ordering (default: normal) */
+    priority?: ContextPriority;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Result of getting pending context for a session
+ */
+export interface PendingContext {
+    /** Merged context string, ready for injection */
+    merged: string;
+    /** Individual entries that were merged */
+    entries: ContextEntry[];
+    /** Whether there's any content to inject */
+    hasContent: boolean;
+}
+/**
+ * Message context from the original user message
+ * Used when injecting to match the message format
+ */
+export interface MessageContext {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+    path?: {
+        cwd?: string;
+        root?: string;
+    };
+    tools?: Record<string, boolean>;
+}
+/**
+ * Output parts from chat.message hook
+ */
+export interface OutputParts {
+    parts: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}
+/**
+ * Injection strategy
+ */
+export type InjectionStrategy = "prepend-parts" | "storage" | "auto";

package/dist/features/donut-state/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Donut State Constants
+ */
+export declare const DONUT_DIR = ".homer";
+export declare const DONUT_FILE = "donut.json";
+export declare const DONUT_STATE_PATH = ".homer/donut.json";
+export declare const NOTEPAD_DIR = "notepads";
+export declare const NOTEPAD_BASE_PATH = ".homer/notepads";
+/** Prometheus plan directory pattern */
+export declare const PROMETHEUS_PLANS_DIR = ".homer/plans";

package/dist/features/donut-state/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./constants";
+export * from "./storage";

package/dist/features/donut-state/storage.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Donut State Storage
+ *
+ * Handles reading/writing donut.json for active plan tracking.
+ */
+import type { DonutState, PlanProgress } from "./types";
+export declare function getDonutFilePath(directory: string): string;
+export declare function readDonutState(directory: string): DonutState | null;
+export declare function writeDonutState(directory: string, state: DonutState): boolean;
+export declare function appendSessionId(directory: string, sessionId: string): DonutState | null;
+export declare function clearDonutState(directory: string): boolean;
+/**
+ * Find Prometheus plan files for this project.
+ * Prometheus stores plans at: {project}/.homer/plans/{name}.md
+ */
+export declare function findPrometheusPlans(directory: string): string[];
+/**
+ * Parse a plan file and count checkbox progress.
+ */
+export declare function getPlanProgress(planPath: string): PlanProgress;
+/**
+ * Extract plan name from file path.
+ */
+export declare function getPlanName(planPath: string): string;
+/**
+ * Create a new donut state for a plan.
+ */
+export declare function createDonutState(planPath: string, sessionId: string): DonutState;

package/dist/features/donut-state/storage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/donut-state/types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Donut State Types
+ *
+ * Manages the active work plan state for Homer orchestrator.
+ * Named after Homer's donuts - the eternal snack that must be consumed.
+ */
+export interface DonutState {
+    /** Absolute path to the active plan file */
+    active_plan: string;
+    /** ISO timestamp when work started */
+    started_at: string;
+    /** Session IDs that have worked on this plan */
+    session_ids: string[];
+    /** Plan name derived from filename */
+    plan_name: string;
+}
+export interface PlanProgress {
+    /** Total number of checkboxes */
+    total: number;
+    /** Number of completed checkboxes */
+    completed: number;
+    /** Whether all tasks are done */
+    isComplete: boolean;
+}

package/dist/features/hook-message-injector/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const MESSAGE_STORAGE: string;
+export declare const PART_STORAGE: string;

package/dist/features/hook-message-injector/index.d.ts

@@ -0,0 +1,4 @@
+export { injectHookMessage, findNearestMessageWithFields } from "./injector";
+export type { StoredMessage } from "./injector";
+export type { MessageMeta, OriginalMessageContext, TextPart } from "./types";
+export { MESSAGE_STORAGE } from "./constants";

package/dist/features/hook-message-injector/injector.d.ts

@@ -0,0 +1,11 @@
+import type { OriginalMessageContext, ToolPermission } from "./types";
+export interface StoredMessage {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}
+export declare function findNearestMessageWithFields(messageDir: string): StoredMessage | null;
+export declare function injectHookMessage(sessionID: string, hookContent: string, originalMessage: OriginalMessageContext): boolean;

package/dist/features/hook-message-injector/types.d.ts

@@ -0,0 +1,44 @@
+export type ToolPermission = boolean | "allow" | "deny" | "ask";
+export interface MessageMeta {
+    id: string;
+    sessionID: string;
+    role: "user" | "assistant";
+    time: {
+        created: number;
+        completed?: number;
+    };
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    path?: {
+        cwd: string;
+        root: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}
+export interface OriginalMessageContext {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+    path?: {
+        cwd?: string;
+        root?: string;
+    };
+    tools?: Record<string, ToolPermission>;
+}
+export interface TextPart {
+    id: string;
+    type: "text";
+    text: string;
+    synthetic: boolean;
+    time: {
+        start: number;
+        end: number;
+    };
+    messageID: string;
+    sessionID: string;
+}

package/dist/features/opencode-skill-loader/async-loader.d.ts

@@ -0,0 +1,6 @@
+import type { SkillScope, LoadedSkill } from "./types";
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export declare function mapWithConcurrency<T, R>(items: T[], mapper: (item: T) => Promise<R>, concurrency: number): Promise<R[]>;
+export declare function loadMcpJsonFromDirAsync(skillDir: string): Promise<SkillMcpConfig | undefined>;
+export declare function loadSkillFromPathAsync(skillPath: string, resolvedPath: string, defaultName: string, scope: SkillScope): Promise<LoadedSkill | null>;
+export declare function discoverSkillsInDirAsync(skillsDir: string): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/async-loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/opencode-skill-loader/blocking.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill, SkillScope } from "./types";
+export declare function discoverAllSkillsBlocking(dirs: string[], scopes: SkillScope[]): LoadedSkill[];

package/dist/features/opencode-skill-loader/blocking.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/opencode-skill-loader/discover-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/opencode-skill-loader/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./loader";
+export * from "./merger";
+export * from "./skill-content";

package/dist/features/opencode-skill-loader/loader.d.ts

@@ -0,0 +1,16 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { LoadedSkill } from "./types";
+export declare function loadUserSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadProjectSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeGlobalSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeProjectSkills(): Promise<Record<string, CommandDefinition>>;
+export interface DiscoverSkillsOptions {
+    includeClaudeCodePaths?: boolean;
+}
+export declare function discoverAllSkills(): Promise<LoadedSkill[]>;
+export declare function discoverSkills(options?: DiscoverSkillsOptions): Promise<LoadedSkill[]>;
+export declare function getSkillByName(name: string, options?: DiscoverSkillsOptions): Promise<LoadedSkill | undefined>;
+export declare function discoverUserClaudeSkills(): Promise<LoadedSkill[]>;
+export declare function discoverProjectClaudeSkills(): Promise<LoadedSkill[]>;
+export declare function discoverOpencodeGlobalSkills(): Promise<LoadedSkill[]>;
+export declare function discoverOpencodeProjectSkills(): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/loader.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/opencode-skill-loader/merger.d.ts

@@ -0,0 +1,7 @@
+import type { LoadedSkill } from "./types";
+import type { SkillsConfig } from "../../config/schema";
+import type { BuiltinSkill } from "../builtin-skills/types";
+export interface MergeSkillsOptions {
+    configDir?: string;
+}
+export declare function mergeSkills(builtinSkills: BuiltinSkill[], config: SkillsConfig | undefined, userClaudeSkills: LoadedSkill[], userOpencodeSkills: LoadedSkill[], projectClaudeSkills: LoadedSkill[], projectOpencodeSkills: LoadedSkill[], options?: MergeSkillsOptions): LoadedSkill[];

package/dist/features/opencode-skill-loader/skill-content.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveSkillContent(skillName: string): string | null;
+export declare function resolveMultipleSkills(skillNames: string[]): {
+    resolved: Map<string, string>;
+    notFound: string[];
+};

package/dist/features/opencode-skill-loader/skill-content.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/opencode-skill-loader/types.d.ts

@@ -0,0 +1,34 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export type SkillScope = "builtin" | "config" | "user" | "project" | "opencode" | "opencode-project";
+export interface SkillMetadata {
+    name?: string;
+    description?: string;
+    model?: string;
+    "argument-hint"?: string;
+    agent?: string;
+    subtask?: boolean;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    "allowed-tools"?: string;
+    mcp?: SkillMcpConfig;
+}
+export interface LazyContentLoader {
+    loaded: boolean;
+    content?: string;
+    load: () => Promise<string>;
+}
+export interface LoadedSkill {
+    name: string;
+    path?: string;
+    resolvedPath?: string;
+    definition: CommandDefinition;
+    scope: SkillScope;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string[];
+    mcpConfig?: SkillMcpConfig;
+    lazyContent?: LazyContentLoader;
+}

package/dist/features/skill-mcp-manager/env-cleaner.d.ts

@@ -0,0 +1,2 @@
+export declare const EXCLUDED_ENV_PATTERNS: RegExp[];
+export declare function createCleanMcpEnvironment(customEnv?: Record<string, string>): Record<string, string>;

package/dist/features/skill-mcp-manager/env-cleaner.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/skill-mcp-manager/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { SkillMcpManager } from "./manager";

package/dist/features/skill-mcp-manager/manager.d.ts

@@ -0,0 +1,29 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Tool, Resource, Prompt } from "@modelcontextprotocol/sdk/types.js";
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+import type { SkillMcpClientInfo, SkillMcpServerContext } from "./types";
+export declare class SkillMcpManager {
+    private clients;
+    private pendingConnections;
+    private cleanupRegistered;
+    private cleanupInterval;
+    private readonly IDLE_TIMEOUT;
+    private getClientKey;
+    private registerProcessCleanup;
+    getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<Client>;
+    private createClient;
+    disconnectSession(sessionID: string): Promise<void>;
+    disconnectAll(): Promise<void>;
+    private startCleanupTimer;
+    private stopCleanupTimer;
+    private cleanupIdleClients;
+    listTools(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Tool[]>;
+    listResources(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Resource[]>;
+    listPrompts(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Prompt[]>;
+    callTool(info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record<string, unknown>): Promise<unknown>;
+    readResource(info: SkillMcpClientInfo, context: SkillMcpServerContext, uri: string): Promise<unknown>;
+    getPrompt(info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record<string, string>): Promise<unknown>;
+    private getOrCreateClientWithRetry;
+    getConnectedServers(): string[];
+    isConnected(info: SkillMcpClientInfo): boolean;
+}

package/dist/features/skill-mcp-manager/manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/skill-mcp-manager/types.d.ts

@@ -0,0 +1,11 @@
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+export type SkillMcpConfig = Record<string, ClaudeCodeMcpServer>;
+export interface SkillMcpClientInfo {
+    serverName: string;
+    skillName: string;
+    sessionID: string;
+}
+export interface SkillMcpServerContext {
+    config: ClaudeCodeMcpServer;
+    skillName: string;
+}

package/dist/features/task-toast-manager/index.d.ts

@@ -0,0 +1,2 @@
+export { TaskToastManager, getTaskToastManager, initTaskToastManager } from "./manager";
+export type { TrackedTask, TaskStatus, TaskToastOptions } from "./types";

package/dist/features/task-toast-manager/manager.d.ts

@@ -0,0 +1,56 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { TrackedTask, TaskStatus } from "./types";
+import type { ConcurrencyManager } from "../background-agent/concurrency";
+type OpencodeClient = PluginInput["client"];
+export declare class TaskToastManager {
+    private tasks;
+    private client;
+    private concurrencyManager?;
+    constructor(client: OpencodeClient, concurrencyManager?: ConcurrencyManager);
+    setConcurrencyManager(manager: ConcurrencyManager): void;
+    addTask(task: {
+        id: string;
+        description: string;
+        agent: string;
+        isBackground: boolean;
+        status?: TaskStatus;
+        skills?: string[];
+    }): void;
+    /**
+     * Update task status
+     */
+    updateTask(id: string, status: TaskStatus): void;
+    /**
+     * Remove completed/error task
+     */
+    removeTask(id: string): void;
+    /**
+     * Get all running tasks (newest first)
+     */
+    getRunningTasks(): TrackedTask[];
+    /**
+     * Get all queued tasks
+     */
+    getQueuedTasks(): TrackedTask[];
+    /**
+     * Format duration since task started
+     */
+    private formatDuration;
+    private getConcurrencyInfo;
+    private buildTaskListMessage;
+    /**
+     * Show consolidated toast with all running/queued tasks
+     */
+    private showTaskListToast;
+    /**
+     * Show task completion toast
+     */
+    showCompletionToast(task: {
+        id: string;
+        description: string;
+        duration: string;
+    }): void;
+}
+export declare function getTaskToastManager(): TaskToastManager | null;
+export declare function initTaskToastManager(client: OpencodeClient, concurrencyManager?: ConcurrencyManager): TaskToastManager;
+export {};

package/dist/features/task-toast-manager/manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/task-toast-manager/types.d.ts

@@ -0,0 +1,16 @@
+export type TaskStatus = "running" | "queued" | "completed" | "error";
+export interface TrackedTask {
+    id: string;
+    description: string;
+    agent: string;
+    status: TaskStatus;
+    startedAt: Date;
+    isBackground: boolean;
+    skills?: string[];
+}
+export interface TaskToastOptions {
+    title: string;
+    message: string;
+    variant: "info" | "success" | "warning" | "error";
+    duration?: number;
+}

package/dist/google-auth.d.ts

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