arggon-harness 0.1.0

package/dist/plugin/hooks/workflow-gate.js

@@ -0,0 +1,78 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import * as Registry from "../engine/registry.js";
+export async function workflowGatePermission(input, output, ctx) {
+    if (input.tool !== "task")
+        return;
+    if (input.agent !== "orchestrator")
+        return;
+    const subagentType = input.args?.subagent_type || input.args?.subagentType;
+    if (!subagentType)
+        return;
+    try {
+        const registry = await Registry.readRegistry(ctx.projectRoot);
+        const activeChanges = registry.changes.filter(c => c.status === "active");
+        if (subagentType === "general" || subagentType === "explore") {
+            output.status = "deny";
+            return;
+        }
+        if (subagentType === "spec-propose") {
+            output.status = "allow";
+            return;
+        }
+        if (subagentType === "spec-apply") {
+            const hasReadyChange = activeChanges.some(c => {
+                const artifacts = c.artifacts || {};
+                return artifacts.proposal === true &&
+                    artifacts.specs === true &&
+                    artifacts["design-tech"] === true &&
+                    artifacts.tasks === true;
+            });
+            output.status = hasReadyChange ? "allow" : "deny";
+            return;
+        }
+        if (subagentType === "spec-verify") {
+            const hasCompleteTasks = activeChanges.some(c => c.progress >= 100);
+            output.status = hasCompleteTasks ? "allow" : "deny";
+            return;
+        }
+        if (subagentType === "spec-archive") {
+            const hasVerifiedChange = await Promise.all(activeChanges
+                .filter(c => c.progress >= 100)
+                .map(async (c) => {
+                const passedPath = path.join(ctx.projectRoot, "spec", "changes", c.name, ".verify", "passed");
+                try {
+                    await fs.access(passedPath);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            })).then(results => results.some(Boolean));
+            output.status = hasVerifiedChange ? "allow" : "deny";
+            return;
+        }
+    }
+    catch {
+        output.status = "deny";
+    }
+}
+const SPEC_AGENT_TYPES = [
+    "spec-propose",
+    "spec-apply",
+    "spec-verify",
+    "spec-archive",
+];
+export async function workflowGateToolDefinition(input, output, _ctx) {
+    if (input.toolID !== "task")
+        return;
+    const agent = input.agent ?? input.agent;
+    if (agent !== "orchestrator")
+        return;
+    if (output.parameters?.properties?.subagent_type) {
+        output.parameters.properties.subagent_type.enum = SPEC_AGENT_TYPES;
+        output.parameters.properties.subagent_type.description =
+            "The spec workflow agent to delegate to. Follow the workflow: explore → propose → apply → verify → archive";
+    }
+}
+//# sourceMappingURL=workflow-gate.js.map

package/dist/plugin/hooks/workflow-gate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-gate.js","sourceRoot":"","sources":["../../../src/plugin/hooks/workflow-gate.ts"],"names":[],"mappings":"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"}

package/dist/plugin/index.d.ts

@@ -0,0 +1,423 @@
+import { z } from "zod";
+import { buildSubagentContextBlock, buildOrchestratorDelegationBlock } from "./hooks/context-injection.js";
+export { buildSubagentContextBlock, buildOrchestratorDelegationBlock };
+declare const _default: {
+    id: string;
+    server: (input: any) => Promise<{
+        tool: {
+            spec_change_new: {
+                description: string;
+                args: {
+                    name: z.ZodString;
+                    schema: z.ZodOptional<z.ZodString>;
+                };
+                execute(args: {
+                    name: string;
+                    schema?: string | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_change_status: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                };
+                execute(args: {
+                    changeName: string;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_change_list: {
+                description: string;
+                args: {};
+                execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_artifact_instr: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                    artifactId: z.ZodOptional<z.ZodString>;
+                };
+                execute(args: {
+                    changeName: string;
+                    artifactId?: string | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_validate: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                    artifactId: z.ZodOptional<z.ZodString>;
+                };
+                execute(args: {
+                    changeName: string;
+                    artifactId?: string | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_specs_apply: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                    dryRun: z.ZodOptional<z.ZodBoolean>;
+                };
+                execute(args: {
+                    changeName: string;
+                    dryRun?: boolean | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_change_archive: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                };
+                execute(args: {
+                    changeName: string;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_schema_list: {
+                description: string;
+                args: {};
+                execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_verify: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                    dimensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                };
+                execute(args: {
+                    changeName: string;
+                    dimensions?: string[] | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_task_progress: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                    taskId: z.ZodOptional<z.ZodString>;
+                    status: z.ZodOptional<z.ZodString>;
+                };
+                execute(args: {
+                    changeName: string;
+                    taskId?: string | undefined;
+                    status?: string | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_integrity_check: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                };
+                execute(args: {
+                    changeName: string;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_registry_update: {
+                description: string;
+                args: {};
+                execute(args: Record<string, never>, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_design_wireframe: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                    pages: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        name: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                        layout: z.ZodArray<z.ZodObject<{
+                            region: z.ZodString;
+                            order: z.ZodNumber;
+                            style: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>;
+                        components: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            type: z.ZodString;
+                            region: z.ZodString;
+                            position: z.ZodObject<{
+                                x: z.ZodNumber;
+                                y: z.ZodNumber;
+                            }, z.core.$strip>;
+                            size: z.ZodObject<{
+                                width: z.ZodNumber;
+                                height: z.ZodNumber;
+                            }, z.core.$strip>;
+                            properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>>;
+                    flows: z.ZodOptional<z.ZodObject<{
+                        user_flows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            name: z.ZodString;
+                            description: z.ZodOptional<z.ZodString>;
+                            steps: z.ZodArray<z.ZodObject<{
+                                id: z.ZodString;
+                                from_page: z.ZodString;
+                                to_page: z.ZodString;
+                                trigger: z.ZodString;
+                                description: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>>;
+                    annotations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        page_id: z.ZodOptional<z.ZodString>;
+                        note: z.ZodString;
+                        category: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>>;
+                    html_preview: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                };
+                execute(args: {
+                    changeName: string;
+                    pages: {
+                        id: string;
+                        name: string;
+                        layout: {
+                            region: string;
+                            order: number;
+                            style?: string | undefined;
+                        }[];
+                        description?: string | undefined;
+                        components?: {
+                            id: string;
+                            type: string;
+                            region: string;
+                            position: {
+                                x: number;
+                                y: number;
+                            };
+                            size: {
+                                width: number;
+                                height: number;
+                            };
+                            properties?: Record<string, any> | undefined;
+                        }[] | undefined;
+                    }[];
+                    html_preview: boolean;
+                    flows?: {
+                        user_flows?: {
+                            id: string;
+                            name: string;
+                            steps: {
+                                id: string;
+                                from_page: string;
+                                to_page: string;
+                                trigger: string;
+                                description?: string | undefined;
+                            }[];
+                            description?: string | undefined;
+                        }[] | undefined;
+                    } | undefined;
+                    annotations?: {
+                        id: string;
+                        note: string;
+                        page_id?: string | undefined;
+                        category?: string | undefined;
+                    }[] | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_design_hifi: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                    color_palette: z.ZodObject<{
+                        primary: z.ZodObject<{
+                            base: z.ZodString;
+                            hover: z.ZodOptional<z.ZodString>;
+                            active: z.ZodOptional<z.ZodString>;
+                            disabled: z.ZodOptional<z.ZodString>;
+                            contrast: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                        secondary: z.ZodObject<{
+                            base: z.ZodString;
+                            hover: z.ZodOptional<z.ZodString>;
+                            active: z.ZodOptional<z.ZodString>;
+                            disabled: z.ZodOptional<z.ZodString>;
+                            contrast: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                        accent: z.ZodObject<{
+                            base: z.ZodString;
+                            hover: z.ZodOptional<z.ZodString>;
+                            active: z.ZodOptional<z.ZodString>;
+                            disabled: z.ZodOptional<z.ZodString>;
+                            contrast: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                        neutral: z.ZodObject<{
+                            base: z.ZodString;
+                            hover: z.ZodOptional<z.ZodString>;
+                            active: z.ZodOptional<z.ZodString>;
+                            disabled: z.ZodOptional<z.ZodString>;
+                            contrast: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>;
+                        semantic: z.ZodOptional<z.ZodObject<{
+                            success: z.ZodString;
+                            warning: z.ZodString;
+                            error: z.ZodString;
+                            info: z.ZodString;
+                        }, z.core.$strip>>;
+                        surfaces: z.ZodOptional<z.ZodObject<{
+                            background: z.ZodString;
+                            foreground: z.ZodString;
+                            card: z.ZodString;
+                            border: z.ZodString;
+                            muted: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                    typography: z.ZodObject<{
+                        families: z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            stack: z.ZodString;
+                            role: z.ZodString;
+                        }, z.core.$strip>>;
+                        scale: z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            size: z.ZodString;
+                            weight: z.ZodNumber;
+                            line_height: z.ZodNumber;
+                            letter_spacing: z.ZodOptional<z.ZodString>;
+                            role: z.ZodString;
+                        }, z.core.$strip>>;
+                    }, z.core.$strip>;
+                    spacing: z.ZodObject<{
+                        base_unit: z.ZodNumber;
+                        scale: z.ZodArray<z.ZodNumber>;
+                    }, z.core.$strip>;
+                    component_library: z.ZodOptional<z.ZodObject<{
+                        button: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+                        card: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+                        input: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+                        navigation: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+                    }, z.core.$strip>>;
+                    breakpoints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        min_width: z.ZodNumber;
+                        columns: z.ZodNumber;
+                        rules: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>>;
+                    html_preview: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+                };
+                execute(args: {
+                    changeName: string;
+                    color_palette: {
+                        primary: {
+                            base: string;
+                            hover?: string | undefined;
+                            active?: string | undefined;
+                            disabled?: string | undefined;
+                            contrast?: string | undefined;
+                        };
+                        secondary: {
+                            base: string;
+                            hover?: string | undefined;
+                            active?: string | undefined;
+                            disabled?: string | undefined;
+                            contrast?: string | undefined;
+                        };
+                        accent: {
+                            base: string;
+                            hover?: string | undefined;
+                            active?: string | undefined;
+                            disabled?: string | undefined;
+                            contrast?: string | undefined;
+                        };
+                        neutral: {
+                            base: string;
+                            hover?: string | undefined;
+                            active?: string | undefined;
+                            disabled?: string | undefined;
+                            contrast?: string | undefined;
+                        };
+                        semantic?: {
+                            success: string;
+                            warning: string;
+                            error: string;
+                            info: string;
+                        } | undefined;
+                        surfaces?: {
+                            background: string;
+                            foreground: string;
+                            card: string;
+                            border: string;
+                            muted: string;
+                        } | undefined;
+                    };
+                    typography: {
+                        families: {
+                            name: string;
+                            stack: string;
+                            role: string;
+                        }[];
+                        scale: {
+                            name: string;
+                            size: string;
+                            weight: number;
+                            line_height: number;
+                            role: string;
+                            letter_spacing?: string | undefined;
+                        }[];
+                    };
+                    spacing: {
+                        base_unit: number;
+                        scale: number[];
+                    };
+                    html_preview: boolean;
+                    component_library?: {
+                        button?: any[] | undefined;
+                        card?: any[] | undefined;
+                        input?: any[] | undefined;
+                        navigation?: any[] | undefined;
+                    } | undefined;
+                    breakpoints?: {
+                        name: string;
+                        min_width: number;
+                        columns: number;
+                        rules?: string[] | undefined;
+                    }[] | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_design_critique: {
+                description: string;
+                args: {
+                    changeName: z.ZodString;
+                    artifactType: z.ZodOptional<z.ZodEnum<{
+                        wireframe: "wireframe";
+                        hifi: "hifi";
+                    }>>;
+                    threshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+                    focusDimensions: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        philosophy: "philosophy";
+                        hierarchy: "hierarchy";
+                        detail: "detail";
+                        functionality: "functionality";
+                        innovation: "innovation";
+                    }>>>;
+                };
+                execute(args: {
+                    changeName: string;
+                    threshold: number;
+                    artifactType?: "wireframe" | "hifi" | undefined;
+                    focusDimensions?: ("philosophy" | "hierarchy" | "detail" | "functionality" | "innovation")[] | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+            spec_init: {
+                description: string;
+                args: {
+                    context: z.ZodString;
+                    schema: z.ZodOptional<z.ZodString>;
+                    rules: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+                    force: z.ZodOptional<z.ZodBoolean>;
+                };
+                execute(args: {
+                    context: string;
+                    schema?: string | undefined;
+                    rules?: Record<string, string[]> | undefined;
+                    force?: boolean | undefined;
+                }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
+            };
+        };
+        "experimental.chat.system.transform": (input: any, output: any) => Promise<void>;
+        event: (event: any) => Promise<void>;
+        "permission.ask": (input: any, output: any) => Promise<void>;
+        "tool.definition": (input: any, output: any) => Promise<void>;
+    }>;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,OAAO,EAA6B,yBAAyB,EAAE,gCAAgC,EAAE,MAAM,8BAA8B,CAAA;AAKrI,OAAO,EAAE,yBAAyB,EAAE,gCAAgC,EAAE,CAAA;;;oBAI9C,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sDA8N6B,GAAG,UAAU,GAAG;uBAW/C,GAAG;kCAIQ,GAAG,UAAU,GAAG;mCAIf,GAAG,UAAU,GAAG;;;AAnPrD,wBAuPE"}