thoth-plugin 1.2.0 → 1.2.2

package/dist/schemas/skill.d.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+declare const SkillParameterSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        string: "string";
+        number: "number";
+        boolean: "boolean";
+        object: "object";
+        array: "array";
+    }>;
+    description: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+    default: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+export declare const SkillFrontmatterSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    triggers: z.ZodArray<z.ZodString>;
+    inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            string: "string";
+            number: "number";
+            boolean: "boolean";
+            object: "object";
+            array: "array";
+        }>;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+        default: z.ZodOptional<z.ZodAny>;
+    }, z.core.$strip>>>;
+    output: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            text: "text";
+            json: "json";
+            markdown: "markdown";
+            code: "code";
+        }>;
+        schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        memory: z.ZodDefault<z.ZodBoolean>;
+        permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    created: z.ZodOptional<z.ZodString>;
+    updated: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const SkillSchema: z.ZodObject<{
+    path: z.ZodString;
+    frontmatter: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        version: z.ZodString;
+        author: z.ZodOptional<z.ZodString>;
+        triggers: z.ZodArray<z.ZodString>;
+        inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<{
+                string: "string";
+                number: "number";
+                boolean: "boolean";
+                object: "object";
+                array: "array";
+            }>;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            default: z.ZodOptional<z.ZodAny>;
+        }, z.core.$strip>>>;
+        output: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                text: "text";
+                json: "json";
+                markdown: "markdown";
+                code: "code";
+            }>;
+            schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>>;
+        constraints: z.ZodOptional<z.ZodObject<{
+            models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            memory: z.ZodDefault<z.ZodBoolean>;
+            permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        created: z.ZodOptional<z.ZodString>;
+        updated: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type SkillFrontmatter = z.infer<typeof SkillFrontmatterSchema>;
+export type SkillParameter = z.infer<typeof SkillParameterSchema>;
+export type Skill = z.infer<typeof SkillSchema>;
+export {};

package/dist/sdk/index.d.ts

@@ -0,0 +1,4 @@
+export { ThothClient, createThothClient, type ThothClientConfig, type SessionOptions, type SessionResult, type PipelineUnit, type PipelineOutput, } from "./thoth-client";
+export { SentinelService, createMorningBootWorkflow, createDeepResearchWorkflow, type SentinelConfig, type WorkflowDefinition, type WorkflowContext, type Trigger, type ScheduleTrigger, type FileChangeTrigger, type ManualTrigger, type TriggerType, } from "./sentinel-service";
+export { SkillRunner, type SkillTest, type TestResult, } from "./skill-runner";
+export * from "./workflows";

package/dist/sdk/sentinel-service.d.ts

@@ -0,0 +1,71 @@
+import { ThothClient, type SessionResult } from "./thoth-client";
+import { type TemporalContext } from "../shared";
+export type TriggerType = "schedule" | "file-change" | "manual";
+export interface ScheduleTrigger {
+    type: "schedule";
+    cron?: string;
+    time?: string;
+    days?: Array<"mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun">;
+}
+export interface FileChangeTrigger {
+    type: "file-change";
+    paths: string[];
+    debounceMs?: number;
+}
+export interface ManualTrigger {
+    type: "manual";
+}
+export type Trigger = ScheduleTrigger | FileChangeTrigger | ManualTrigger;
+export interface WorkflowDefinition {
+    name: string;
+    description?: string;
+    triggers: Trigger[];
+    quietHours?: {
+        start: string;
+        end: string;
+    };
+    execute: (context: WorkflowContext) => Promise<string>;
+}
+export interface WorkflowContext {
+    temporal: TemporalContext;
+    client: ThothClient;
+    triggerType: TriggerType;
+    triggerData?: unknown;
+}
+export interface SentinelConfig {
+    pollIntervalMs?: number;
+    quietHours?: {
+        start: string;
+        end: string;
+    };
+    enabled?: boolean;
+}
+export declare class SentinelService {
+    private client;
+    private config;
+    private workflows;
+    private schedules;
+    private running;
+    private pollTimer;
+    constructor(client: ThothClient, config?: SentinelConfig);
+    registerWorkflow(workflow: WorkflowDefinition): void;
+    unregisterWorkflow(name: string): void;
+    start(): Promise<void>;
+    stop(): void;
+    triggerWorkflow(name: string, triggerType?: TriggerType, triggerData?: unknown): Promise<SessionResult | null>;
+    listWorkflows(): Array<{
+        name: string;
+        description?: string;
+        triggers: Trigger[];
+    }>;
+    private tick;
+    private executeWorkflow;
+    private updateSchedules;
+    private updateNextRun;
+    private calculateNextRun;
+    private isQuietHours;
+    private isInTimeRange;
+    private timeToMinutes;
+}
+export declare function createDeepResearchWorkflow(): WorkflowDefinition;
+export declare function createMorningBootWorkflow(): WorkflowDefinition;

package/dist/sdk/skill-runner.d.ts

@@ -0,0 +1,21 @@
+import { ThothClient } from "./thoth-client";
+export interface SkillTest {
+    name: string;
+    skillName: string;
+    input: string;
+    expectedOutput?: string | RegExp;
+    timeoutMs?: number;
+}
+export interface TestResult {
+    testName: string;
+    success: boolean;
+    output: string;
+    error?: string;
+    durationMs: number;
+}
+export declare class SkillRunner {
+    private client;
+    constructor(client: ThothClient);
+    runTest(test: SkillTest): Promise<TestResult>;
+    runSuite(tests: SkillTest[]): Promise<TestResult[]>;
+}

package/dist/sdk/thoth-client.d.ts

@@ -0,0 +1,51 @@
+import { type OpencodeClient } from "@opencode-ai/sdk";
+export interface ThothClientConfig {
+    baseUrl?: string;
+    spawnServer?: boolean;
+    port?: number;
+    defaultModel?: string;
+    client?: OpencodeClient;
+}
+export interface SessionOptions {
+    agent?: string;
+    model?: string;
+    title?: string;
+    files?: string[];
+}
+export interface SessionResult {
+    sessionId: string;
+    response: string;
+    success: boolean;
+    error?: string;
+}
+export type PipelineOutput = string | Array<PipelineOutput>;
+export type PipelineUnit = {
+    prompt: string | ((input: PipelineOutput) => string);
+    options?: SessionOptions;
+} | {
+    parallel: PipelineUnit[];
+} | {
+    sequence: PipelineUnit[];
+};
+export declare class ThothClient {
+    private client;
+    private config;
+    private serverProcess;
+    constructor(config?: ThothClientConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    runSession(prompt: string, options?: SessionOptions): Promise<SessionResult>;
+    runPipeline(units: PipelineUnit[]): Promise<PipelineOutput[]>;
+    private executeUnit;
+    runParallel(tasks: Array<{
+        prompt: string;
+        options?: SessionOptions;
+    }>): Promise<SessionResult[]>;
+    abortSession(sessionId: string): Promise<void>;
+    listAgents(): Promise<string[]>;
+    isHealthy(): Promise<boolean>;
+    notify(message: string, level?: "info" | "success" | "warning" | "error"): Promise<void>;
+    showToast(message: string, variant?: "info" | "success" | "warning" | "error"): Promise<void>;
+    private extractResponseText;
+}
+export declare function createThothClient(config?: ThothClientConfig): Promise<ThothClient>;

package/dist/sdk/workflows/calendar-watcher.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowDefinition } from "../sentinel-service";
+export declare function createCalendarWatcherWorkflow(): WorkflowDefinition;

package/dist/sdk/workflows/inbox-watcher.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowDefinition } from "../sentinel-service";
+export declare function createInboxWatcherWorkflow(): WorkflowDefinition;

package/dist/sdk/workflows/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./calendar-watcher";
+export * from "./inbox-watcher";
+export * from "./task-watcher";
+export * from "./system-watcher";

package/dist/sdk/workflows/system-watcher.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowDefinition } from "../sentinel-service";
+export declare function createSystemWatcherWorkflow(): WorkflowDefinition;

package/dist/sdk/workflows/task-watcher.d.ts

@@ -0,0 +1,2 @@
+import type { WorkflowDefinition } from "../sentinel-service";
+export declare function createTaskWatcherWorkflow(): WorkflowDefinition;

package/dist/services/index.d.ts

@@ -0,0 +1 @@
+export * from "./skill-registry";

package/dist/services/skill-registry.d.ts

@@ -0,0 +1,23 @@
+import { type Skill } from "../schemas/skill";
+export type SkillScope = "user" | "project" | "builtin";
+export interface LoadedSkill {
+    name: string;
+    scope: SkillScope;
+    path: string;
+    data: Skill;
+    extras: {
+        references: string[];
+        scripts: string[];
+        assets: string[];
+    };
+}
+export declare class SkillRegistry {
+    private skills;
+    private readonly npmDefaultsPath;
+    constructor();
+    loadSkills(): Promise<void>;
+    getSkill(name: string): LoadedSkill | undefined;
+    getAllSkills(): LoadedSkill[];
+    private discoverSkills;
+    private loadSingleSkill;
+}

package/dist/tools/skill/tools.d.ts

@@ -1,2 +1,3 @@
 import { tool } from "@opencode-ai/plugin";
-export declare function createSkillTool(): ReturnType<typeof tool>;
+import type { SkillRegistry } from "../../services/skill-registry";
+export declare function createSkillTool(registry: SkillRegistry): ReturnType<typeof tool>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-plugin",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "Thoth - Root-level life orchestrator for OpenCode. Unified AI chief of staff combining Sisyphus execution quality, Personal-OS rhythms, and Thoth relationship model.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,7 +9,8 @@
     "thoth": "./dist/cli.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "defaults"
   ],
   "exports": {
     ".": {
@@ -21,6 +22,8 @@
   "scripts": {
     "build": "bun build src/index.ts src/cli.ts --outdir dist --target bun --format esm && cp -r defaults dist/ && (tsc --emitDeclarationOnly || true) && bun run build:schema",
     "build:schema": "bun run script/build-schema.ts",
+    "lint:skills": "bun run script/lint-skills.ts",
+    "test:skills": "bun run script/test-skills.ts",
     "clean": "rm -rf dist",
     "prepublishOnly": "bun run clean && bun run build",
     "typecheck": "tsc --noEmit",
@@ -44,11 +47,13 @@
   },
   "dependencies": {
     "@opencode-ai/plugin": "^1.0.162",
+    "@opencode-ai/sdk": "^1.0.162",
     "zod": "^4.1.8"
   },
   "devDependencies": {
     "bun-types": "latest",
     "typescript": "^5.7.3",
-    "zod-to-json-schema": "^3.25.1"
+    "zod-to-json-schema": "^3.25.1",
+    "yaml": "^2.7.0"
   }
 }