oh-my-opencode 0.3.3 → 0.4.0

package/dist/hooks/auto-update-checker/cache.d.ts

@@ -0,0 +1 @@
+export declare function invalidateCache(): boolean;

package/dist/hooks/auto-update-checker/checker.d.ts

@@ -0,0 +1,6 @@
+import type { UpdateCheckResult } from "./types";
+export declare function isLocalDevMode(directory: string): boolean;
+export declare function findPluginEntry(directory: string): string | null;
+export declare function getCachedVersion(): string | null;
+export declare function getLatestVersion(): Promise<string | null>;
+export declare function checkForUpdate(directory: string): Promise<UpdateCheckResult>;

package/dist/hooks/auto-update-checker/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const PACKAGE_NAME = "oh-my-opencode";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/oh-my-opencode/dist-tags";
+export declare const NPM_FETCH_TIMEOUT = 5000;
+export declare const CACHE_DIR: string;
+export declare const VERSION_FILE: string;
+export declare const INSTALLED_PACKAGE_JSON: string;
+export declare const USER_CONFIG_DIR: string;
+export declare const USER_OPENCODE_CONFIG: string;

package/dist/hooks/auto-update-checker/index.d.ts

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createAutoUpdateCheckerHook(ctx: PluginInput): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export type { UpdateCheckResult } from "./types";
+export { checkForUpdate } from "./checker";
+export { invalidateCache } from "./cache";

package/dist/hooks/auto-update-checker/types.d.ts

@@ -0,0 +1,19 @@
+export interface NpmDistTags {
+    latest: string;
+    [key: string]: string;
+}
+export interface OpencodeConfig {
+    plugin?: string[];
+    [key: string]: unknown;
+}
+export interface PackageJson {
+    version: string;
+    name?: string;
+    [key: string]: unknown;
+}
+export interface UpdateCheckResult {
+    needsUpdate: boolean;
+    currentVersion: string | null;
+    latestVersion: string | null;
+    isLocalDev: boolean;
+}

package/dist/hooks/background-notification/index.d.ts

@@ -0,0 +1,12 @@
+import type { BackgroundManager } from "../../features/background-agent";
+interface Event {
+    type: string;
+    properties?: Record<string, unknown>;
+}
+interface EventInput {
+    event: Event;
+}
+export declare function createBackgroundNotificationHook(manager: BackgroundManager): {
+    event: ({ event }: EventInput) => Promise<void>;
+};
+export type { BackgroundNotificationHookConfig } from "./types";

package/dist/hooks/background-notification/types.d.ts

@@ -0,0 +1,4 @@
+import type { BackgroundTask } from "../../features/background-agent";
+export interface BackgroundNotificationHookConfig {
+    formatNotification?: (tasks: BackgroundTask[]) => string;
+}

package/dist/hooks/index.d.ts

@@ -10,3 +10,6 @@ export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detec
 export { createAnthropicAutoCompactHook } from "./anthropic-auto-compact";
 export { createThinkModeHook } from "./think-mode";
 export { createClaudeCodeHooksHook } from "./claude-code-hooks";
+export { createRulesInjectorHook } from "./rules-injector";
+export { createBackgroundNotificationHook } from "./background-notification";
+export { createAutoUpdateCheckerHook } from "./auto-update-checker";

package/dist/hooks/rules-injector/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const RULES_INJECTOR_STORAGE: string;
+export declare const PROJECT_MARKERS: string[];
+export declare const PROJECT_RULE_SUBDIRS: [string, string][];
+export declare const USER_RULE_DIR = ".claude/rules";
+export declare const RULE_EXTENSIONS: string[];

package/dist/hooks/rules-injector/finder.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Candidate rule file with metadata for filtering and sorting
+ */
+export interface RuleFileCandidate {
+    /** Absolute path to the rule file */
+    path: string;
+    /** Real path after symlink resolution (for duplicate detection) */
+    realPath: string;
+    /** Whether this is a global/user-level rule */
+    isGlobal: boolean;
+    /** Directory distance from current file (9999 for global rules) */
+    distance: number;
+}
+/**
+ * Find project root by walking up from startPath.
+ * Checks for PROJECT_MARKERS (.git, pyproject.toml, package.json, etc.)
+ *
+ * @param startPath - Starting path to search from (file or directory)
+ * @returns Project root path or null if not found
+ */
+export declare function findProjectRoot(startPath: string): string | null;
+/**
+ * Calculate directory distance between a rule file and current file.
+ * Distance is based on common ancestor within project root.
+ *
+ * @param rulePath - Path to the rule file
+ * @param currentFile - Path to the current file being edited
+ * @param projectRoot - Project root for relative path calculation
+ * @returns Distance (0 = same directory, higher = further)
+ */
+export declare function calculateDistance(rulePath: string, currentFile: string, projectRoot: string | null): number;
+/**
+ * Find all rule files for a given context.
+ * Searches from currentFile upward to projectRoot for rule directories,
+ * then user-level directory (~/.claude/rules).
+ *
+ * IMPORTANT: This searches EVERY directory from file to project root.
+ * Not just the project root itself.
+ *
+ * @param projectRoot - Project root path (or null if outside any project)
+ * @param homeDir - User home directory
+ * @param currentFile - Current file being edited (for distance calculation)
+ * @returns Array of rule file candidates sorted by distance
+ */
+export declare function findRuleFiles(projectRoot: string | null, homeDir: string, currentFile: string): RuleFileCandidate[];

package/dist/hooks/rules-injector/index.d.ts

@@ -0,0 +1,22 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface ToolExecuteInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteOutput {
+    title: string;
+    output: string;
+    metadata: unknown;
+}
+interface EventInput {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}
+export declare function createRulesInjectorHook(ctx: PluginInput): {
+    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
+    event: ({ event }: EventInput) => Promise<void>;
+};
+export {};

package/dist/hooks/rules-injector/matcher.d.ts

@@ -0,0 +1,21 @@
+import type { RuleMetadata } from "./types";
+export interface MatchResult {
+    applies: boolean;
+    reason?: string;
+}
+/**
+ * Check if a rule should apply to the current file based on metadata
+ */
+export declare function shouldApplyRule(metadata: RuleMetadata, currentFilePath: string, projectRoot: string | null): MatchResult;
+/**
+ * Check if realPath already exists in cache (symlink deduplication)
+ */
+export declare function isDuplicateByRealPath(realPath: string, cache: Set<string>): boolean;
+/**
+ * Create SHA-256 hash of content, truncated to 16 chars
+ */
+export declare function createContentHash(content: string): string;
+/**
+ * Check if content hash already exists in cache
+ */
+export declare function isDuplicateByContentHash(hash: string, cache: Set<string>): boolean;

package/dist/hooks/rules-injector/parser.d.ts

@@ -0,0 +1,18 @@
+import type { RuleMetadata } from "./types";
+export interface RuleFrontmatterResult {
+    metadata: RuleMetadata;
+    body: string;
+}
+/**
+ * Parse YAML frontmatter from rule file content
+ * Supports:
+ * - Single string: globs: "**\/*.py"
+ * - Inline array: globs: ["**\/*.py", "src/**\/*.ts"]
+ * - Multi-line array:
+ *   globs:
+ *     - "**\/*.py"
+ *     - "src/**\/*.ts"
+ * - Comma-separated: globs: "**\/*.py, src/**\/*.ts"
+ * - Claude Code 'paths' field (alias for globs)
+ */
+export declare function parseRuleFrontmatter(content: string): RuleFrontmatterResult;

package/dist/hooks/rules-injector/storage.d.ts

@@ -0,0 +1,9 @@
+export declare function loadInjectedRules(sessionID: string): {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+};
+export declare function saveInjectedRules(sessionID: string, data: {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+}): void;
+export declare function clearInjectedRules(sessionID: string): void;

package/dist/hooks/rules-injector/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Rule file metadata (Claude Code style frontmatter)
+ * @see https://docs.anthropic.com/en/docs/claude-code/settings#rule-files
+ */
+export interface RuleMetadata {
+    description?: string;
+    globs?: string | string[];
+    alwaysApply?: boolean;
+}
+/**
+ * Rule information with path context and content
+ */
+export interface RuleInfo {
+    /** Absolute path to the rule file */
+    path: string;
+    /** Path relative to project root */
+    relativePath: string;
+    /** Directory distance from target file (0 = same dir) */
+    distance: number;
+    /** Rule file content (without frontmatter) */
+    content: string;
+    /** SHA-256 hash of content for deduplication */
+    contentHash: string;
+    /** Parsed frontmatter metadata */
+    metadata: RuleMetadata;
+    /** Why this rule matched (e.g., "alwaysApply", "glob: *.ts", "path match") */
+    matchReason: string;
+    /** Real path after symlink resolution (for duplicate detection) */
+    realPath: string;
+}
+/**
+ * Session storage for injected rules tracking
+ */
+export interface InjectedRulesData {
+    sessionID: string;
+    /** Content hashes of already injected rules */
+    injectedHashes: string[];
+    /** Real paths of already injected rules (for symlink deduplication) */
+    injectedRealPaths: string[];
+    updatedAt: number;
+}

package/dist/hooks/session-recovery/storage.d.ts

@@ -13,3 +13,4 @@ export declare function findMessagesWithThinkingBlocks(sessionID: string): strin
 export declare function findMessagesWithOrphanThinking(sessionID: string): string[];
 export declare function prependThinkingPart(sessionID: string, messageID: string): boolean;
 export declare function stripThinkingParts(messageID: string): boolean;
+export declare function findMessageByIndexNeedingThinking(sessionID: string, targetIndex: number): string | null;