oh-my-opencode-kikokikok 2.13.0 → 2.14.0

package/dist/config/schema.d.ts

@@ -101,6 +101,10 @@ export declare const HookNameSchema: z.ZodEnum<{
     "claude-code-hooks": "claude-code-hooks";
     "auto-slash-command": "auto-slash-command";
     "edit-error-recovery": "edit-error-recovery";
+    "knowledge-monitor": "knowledge-monitor";
+    "memory-rehydration": "memory-rehydration";
+    "openspec-continuity": "openspec-continuity";
+    "openspec-commitment": "openspec-commitment";
 }>;
 export declare const BuiltinCommandNameSchema: z.ZodEnum<{
     "init-deep": "init-deep";
@@ -1420,6 +1424,155 @@ export declare const RalphLoopConfigSchema: z.ZodObject<{
     default_max_iterations: z.ZodDefault<z.ZodNumber>;
     state_dir: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const MemoryLayerSchema: z.ZodEnum<{
+    user: "user";
+    agent: "agent";
+    session: "session";
+    project: "project";
+    team: "team";
+    org: "org";
+    company: "company";
+}>;
+export declare const Mem0ConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    orgId: z.ZodOptional<z.ZodString>;
+    companyId: z.ZodOptional<z.ZodString>;
+    agentId: z.ZodOptional<z.ZodString>;
+    autoRehydrate: z.ZodDefault<z.ZodBoolean>;
+    rehydrateLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        user: "user";
+        agent: "agent";
+        session: "session";
+        project: "project";
+        team: "team";
+        org: "org";
+        company: "company";
+    }>>>;
+}, z.core.$strip>;
+export declare const CentralHubConfigSchema: z.ZodObject<{
+    url: z.ZodString;
+    branch: z.ZodDefault<z.ZodString>;
+    autoSync: z.ZodDefault<z.ZodBoolean>;
+    syncIntervalMinutes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const KnowledgeRepoConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    rootDir: z.ZodDefault<z.ZodString>;
+    autoLoadPolicies: z.ZodDefault<z.ZodBoolean>;
+    orgId: z.ZodOptional<z.ZodString>;
+    teamId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    centralHub: z.ZodOptional<z.ZodObject<{
+        url: z.ZodString;
+        branch: z.ZodDefault<z.ZodString>;
+        autoSync: z.ZodDefault<z.ZodBoolean>;
+        syncIntervalMinutes: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        memory: z.ZodDefault<z.ZodBoolean>;
+        disk: z.ZodDefault<z.ZodBoolean>;
+        ttlSeconds: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const OpenSpecEnforcementSchema: z.ZodEnum<{
+    off: "off";
+    soft: "soft";
+    hard: "hard";
+}>;
+export declare const OpenSpecChangeTypeSchema: z.ZodEnum<{
+    new_feature: "new_feature";
+    enhancement: "enhancement";
+    bug_fix: "bug_fix";
+    refactoring: "refactoring";
+    breaking_change: "breaking_change";
+    documentation: "documentation";
+    infrastructure: "infrastructure";
+}>;
+export declare const OpenSpecConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    enforcement: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        soft: "soft";
+        hard: "hard";
+    }>>;
+    requireSpecFor: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        new_feature: "new_feature";
+        enhancement: "enhancement";
+        bug_fix: "bug_fix";
+        refactoring: "refactoring";
+        breaking_change: "breaking_change";
+        documentation: "documentation";
+        infrastructure: "infrastructure";
+    }>>>;
+    rootDir: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export declare const MCPKnowledgeProviderConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    searchTool: z.ZodString;
+    getTool: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const NotebookLMProviderConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    defaultNotebookId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const KnowledgeProviderMergeStrategySchema: z.ZodEnum<{
+    score: "score";
+    "round-robin": "round-robin";
+    "provider-priority": "provider-priority";
+}>;
+export declare const KnowledgeProviderConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    providers: z.ZodOptional<z.ZodObject<{
+        local: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            rootDir: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        mem0: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            indexKnowledgeRepo: z.ZodDefault<z.ZodBoolean>;
+            searchLayers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                user: "user";
+                agent: "agent";
+                session: "session";
+                project: "project";
+                team: "team";
+                org: "org";
+                company: "company";
+            }>>>;
+        }, z.core.$strip>>;
+        mcp: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            servers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                searchTool: z.ZodString;
+                getTool: z.ZodOptional<z.ZodString>;
+                config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        notebooklm: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            defaultNotebookId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    search: z.ZodOptional<z.ZodObject<{
+        defaultLimit: z.ZodDefault<z.ZodNumber>;
+        defaultThreshold: z.ZodDefault<z.ZodNumber>;
+        mergeStrategy: z.ZodDefault<z.ZodEnum<{
+            score: "score";
+            "round-robin": "round-robin";
+            "provider-priority": "provider-priority";
+        }>>;
+        providerPriority: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        deduplicate: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
     disabled_mcps: z.ZodOptional<z.ZodArray<z.ZodEnum<{
@@ -1484,6 +1637,10 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         "claude-code-hooks": "claude-code-hooks";
         "auto-slash-command": "auto-slash-command";
         "edit-error-recovery": "edit-error-recovery";
+        "knowledge-monitor": "knowledge-monitor";
+        "memory-rehydration": "memory-rehydration";
+        "openspec-continuity": "openspec-continuity";
+        "openspec-commitment": "openspec-commitment";
     }>>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         "init-deep": "init-deep";
@@ -2699,6 +2856,111 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         default_max_iterations: z.ZodDefault<z.ZodNumber>;
         state_dir: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    mem0: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        sessionId: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+        orgId: z.ZodOptional<z.ZodString>;
+        companyId: z.ZodOptional<z.ZodString>;
+        agentId: z.ZodOptional<z.ZodString>;
+        autoRehydrate: z.ZodDefault<z.ZodBoolean>;
+        rehydrateLayers: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            user: "user";
+            agent: "agent";
+            session: "session";
+            project: "project";
+            team: "team";
+            org: "org";
+            company: "company";
+        }>>>;
+    }, z.core.$strip>>;
+    knowledge_repo: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        rootDir: z.ZodDefault<z.ZodString>;
+        autoLoadPolicies: z.ZodDefault<z.ZodBoolean>;
+        orgId: z.ZodOptional<z.ZodString>;
+        teamId: z.ZodOptional<z.ZodString>;
+        projectId: z.ZodOptional<z.ZodString>;
+        centralHub: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            branch: z.ZodDefault<z.ZodString>;
+            autoSync: z.ZodDefault<z.ZodBoolean>;
+            syncIntervalMinutes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        cache: z.ZodOptional<z.ZodObject<{
+            memory: z.ZodDefault<z.ZodBoolean>;
+            disk: z.ZodDefault<z.ZodBoolean>;
+            ttlSeconds: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    knowledge_provider: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        providers: z.ZodOptional<z.ZodObject<{
+            local: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                rootDir: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            mem0: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                indexKnowledgeRepo: z.ZodDefault<z.ZodBoolean>;
+                searchLayers: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                    user: "user";
+                    agent: "agent";
+                    session: "session";
+                    project: "project";
+                    team: "team";
+                    org: "org";
+                    company: "company";
+                }>>>;
+            }, z.core.$strip>>;
+            mcp: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                servers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    searchTool: z.ZodString;
+                    getTool: z.ZodOptional<z.ZodString>;
+                    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            notebooklm: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                defaultNotebookId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        search: z.ZodOptional<z.ZodObject<{
+            defaultLimit: z.ZodDefault<z.ZodNumber>;
+            defaultThreshold: z.ZodDefault<z.ZodNumber>;
+            mergeStrategy: z.ZodDefault<z.ZodEnum<{
+                score: "score";
+                "round-robin": "round-robin";
+                "provider-priority": "provider-priority";
+            }>>;
+            providerPriority: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            deduplicate: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    openspec: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        enforcement: z.ZodDefault<z.ZodEnum<{
+            off: "off";
+            soft: "soft";
+            hard: "hard";
+        }>>;
+        requireSpecFor: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            new_feature: "new_feature";
+            enhancement: "enhancement";
+            bug_fix: "bug_fix";
+            refactoring: "refactoring";
+            breaking_change: "breaking_change";
+            documentation: "documentation";
+            infrastructure: "infrastructure";
+        }>>>;
+        rootDir: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type OhMyOpenCodeConfig = z.infer<typeof OhMyOpenCodeConfigSchema>;
 export type AgentOverrideConfig = z.infer<typeof AgentOverrideConfigSchema>;
@@ -2714,4 +2976,15 @@ export type DynamicContextPruningConfig = z.infer<typeof DynamicContextPruningCo
 export type SkillsConfig = z.infer<typeof SkillsConfigSchema>;
 export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>;
 export type RalphLoopConfig = z.infer<typeof RalphLoopConfigSchema>;
+export type Mem0Config = z.infer<typeof Mem0ConfigSchema>;
+export type CentralHubConfig = z.infer<typeof CentralHubConfigSchema>;
+export type KnowledgeRepoConfig = z.infer<typeof KnowledgeRepoConfigSchema>;
+export type OpenSpecConfig = z.infer<typeof OpenSpecConfigSchema>;
+export type OpenSpecEnforcement = z.infer<typeof OpenSpecEnforcementSchema>;
+export type OpenSpecChangeType = z.infer<typeof OpenSpecChangeTypeSchema>;
+export type MemoryLayer = z.infer<typeof MemoryLayerSchema>;
+export type KnowledgeProviderConfig = z.infer<typeof KnowledgeProviderConfigSchema>;
+export type KnowledgeProviderMergeStrategy = z.infer<typeof KnowledgeProviderMergeStrategySchema>;
+export type MCPKnowledgeProviderConfig = z.infer<typeof MCPKnowledgeProviderConfigSchema>;
+export type NotebookLMProviderConfig = z.infer<typeof NotebookLMProviderConfigSchema>;
 export { McpNameSchema, type McpName } from "../mcp/types";

package/dist/features/knowledge-provider/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export { KnowledgeProviderRegistry, getKnowledgeProviderRegistry, resetKnowledgeProviderRegistry, } from "./registry";
+export { LocalKnowledgeProvider } from "./providers/local";
+export { Mem0KnowledgeProvider } from "./providers/mem0";
+export { MCPKnowledgeProvider } from "./providers/mcp";
+export type { MCPInvoker } from "./providers/mcp";
+export { NotebookLMKnowledgeProvider } from "./providers/notebooklm";
+export type { NotebookLMProviderConfig } from "./providers/notebooklm";

package/dist/features/knowledge-provider/providers/local.d.ts

@@ -0,0 +1,18 @@
+import type { KnowledgeProvider, KnowledgeQuery, KnowledgeSearchResult, KnowledgeItem, ProviderHealth, LocalProviderConfig } from "../types";
+export declare class LocalKnowledgeProvider implements KnowledgeProvider {
+    readonly name = "local";
+    readonly type: "local";
+    readonly description = "Local file-based knowledge repository";
+    private config;
+    private repository;
+    private initialized;
+    constructor(config?: Partial<LocalProviderConfig>);
+    initialize(): Promise<void>;
+    search(query: KnowledgeQuery): Promise<KnowledgeSearchResult[]>;
+    getById(id: string): Promise<KnowledgeItem | null>;
+    healthCheck(): Promise<ProviderHealth>;
+    private commitToItem;
+    private calculateScore;
+    private isKnowledgeType;
+    private isKnowledgeLayer;
+}

package/dist/features/knowledge-provider/providers/local.test.d.ts

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

package/dist/features/knowledge-provider/providers/mcp.d.ts

@@ -0,0 +1,23 @@
+import type { KnowledgeProvider, KnowledgeQuery, KnowledgeSearchResult, KnowledgeItem, ProviderHealth, MCPProviderConfig } from "../types";
+export interface MCPInvoker {
+    invoke(serverName: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    isServerAvailable(serverName: string): Promise<boolean>;
+}
+export declare class MCPKnowledgeProvider implements KnowledgeProvider {
+    readonly name: string;
+    readonly type: "mcp";
+    readonly description: string;
+    private config;
+    private invoker;
+    private initialized;
+    constructor(config: MCPProviderConfig, invoker: MCPInvoker);
+    initialize(): Promise<void>;
+    search(query: KnowledgeQuery): Promise<KnowledgeSearchResult[]>;
+    getById(id: string): Promise<KnowledgeItem | null>;
+    healthCheck(): Promise<ProviderHealth>;
+    dispose(): Promise<void>;
+    private parseSearchResponse;
+    private responseItemToSearchResult;
+    private parseGetResponse;
+    private inferType;
+}

package/dist/features/knowledge-provider/providers/mem0.d.ts

@@ -0,0 +1,23 @@
+import type { KnowledgeProvider, KnowledgeQuery, KnowledgeSearchResult, KnowledgeItem, ProviderHealth, Mem0ProviderConfig } from "../types";
+import type { Mem0Config } from "../../mem0-memory/types";
+export declare class Mem0KnowledgeProvider implements KnowledgeProvider {
+    private mem0Config;
+    readonly name = "mem0";
+    readonly type: "mem0";
+    readonly description = "Vector-based semantic memory via Mem0";
+    private config;
+    private adapter;
+    private initialized;
+    constructor(config: Mem0ProviderConfig, mem0Config: Mem0Config);
+    initialize(): Promise<void>;
+    search(query: KnowledgeQuery): Promise<KnowledgeSearchResult[]>;
+    getById(id: string): Promise<KnowledgeItem | null>;
+    index(item: KnowledgeItem): Promise<void>;
+    healthCheck(): Promise<ProviderHealth>;
+    private memoryToItem;
+    private extractTitle;
+    private extractSummary;
+    private resolveSearchLayers;
+    private itemLayerToMemoryLayer;
+    private isMemoryLayer;
+}

package/dist/features/knowledge-provider/providers/notebooklm.d.ts

@@ -0,0 +1,34 @@
+import type { KnowledgeProvider, KnowledgeQuery, KnowledgeSearchResult, KnowledgeItem, ProviderHealth } from "../types";
+import type { MCPInvoker } from "./mcp";
+export interface NotebookLMProviderConfig {
+    enabled: boolean;
+    defaultNotebookId?: string;
+}
+interface NotebookInfo {
+    id: string;
+    title: string;
+    description?: string;
+    sourceCount?: number;
+    createdAt?: string;
+    updatedAt?: string;
+}
+export declare class NotebookLMKnowledgeProvider implements KnowledgeProvider {
+    readonly name = "notebooklm";
+    readonly type: "mcp";
+    readonly description = "Google NotebookLM AI-powered knowledge notebooks";
+    private config;
+    private invoker;
+    private initialized;
+    private notebooks;
+    constructor(config: NotebookLMProviderConfig, invoker: MCPInvoker);
+    initialize(): Promise<void>;
+    search(query: KnowledgeQuery): Promise<KnowledgeSearchResult[]>;
+    getById(id: string): Promise<KnowledgeItem | null>;
+    index(item: KnowledgeItem): Promise<void>;
+    healthCheck(): Promise<ProviderHealth>;
+    dispose(): Promise<void>;
+    listNotebooks(): Promise<NotebookInfo[]>;
+    private refreshNotebooks;
+    private getTargetNotebooks;
+}
+export {};

package/dist/features/knowledge-provider/providers/notebooklm.test.d.ts

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

package/dist/features/knowledge-provider/registry.d.ts

@@ -0,0 +1,22 @@
+import type { KnowledgeProvider, KnowledgeQuery, KnowledgeSearchResult, KnowledgeItem, ProviderHealth, IKnowledgeProviderRegistry, KnowledgeProviderRegistryConfig } from "./types";
+export declare class KnowledgeProviderRegistry implements IKnowledgeProviderRegistry {
+    private providers;
+    private config;
+    constructor(config?: Partial<KnowledgeProviderRegistryConfig>);
+    register(provider: KnowledgeProvider): Promise<void>;
+    unregister(name: string): Promise<void>;
+    search(query: KnowledgeQuery): Promise<KnowledgeSearchResult[]>;
+    getById(id: string): Promise<KnowledgeItem | null>;
+    getProviders(): KnowledgeProvider[];
+    getProvider(name: string): KnowledgeProvider | undefined;
+    healthCheck(): Promise<Map<string, ProviderHealth>>;
+    private getTargetProviders;
+    private mergeResults;
+    private roundRobinMerge;
+    private priorityMerge;
+    private deduplicateResults;
+    private contentHash;
+    private parseId;
+}
+export declare function getKnowledgeProviderRegistry(): KnowledgeProviderRegistry;
+export declare function resetKnowledgeProviderRegistry(): void;

package/dist/features/knowledge-provider/registry.test.d.ts

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