@osovv/vv-opencode 1.4.5 → 1.6.0

package/dist/plugins/hashline-edit/schemas.d.ts

@@ -0,0 +1,246 @@
+import type { z, ZodRawShape } from "zod";
+import { type ContractIssue, type OwnedToolContract } from "../../lib/agent-tool-contract.js";
+/** Registered tool id for the hash-anchored editor. */
+export declare const HASHLINE_EDIT_TOOL_ID = "hashline_edit";
+/** Registered tool id for the dsh str_replace_editor. */
+export declare const STR_REPLACE_EDITOR_TOOL_ID = "str_replace_editor";
+/** Canonical hash-anchored operation vocabulary. */
+export declare const HASHLINE_EDIT_OPS: readonly ["replace", "replace_range", "append", "prepend"];
+/** Union of hash-anchored operation identifiers. */
+export type HashlineToolOp = (typeof HASHLINE_EDIT_OPS)[number];
+/**
+ * Loose tool-facing edit input accepted by the normalizer. The registered schema
+ * below is stricter (required op/lines), but the normalizer must describe and
+ * reject malformed raw input deterministically for direct calls and tests.
+ */
+export interface RawHashlineEdit {
+    op?: HashlineToolOp;
+    pos?: string;
+    end?: string;
+    lines?: string | string[] | null;
+}
+/** Canonical str_replace_editor command vocabulary. */
+export declare const STR_REPLACE_EDITOR_COMMANDS: readonly ["view", "create", "str_replace", "insert"];
+/** Union of str_replace_editor command identifiers. */
+export type StrReplaceEditorCommand = (typeof STR_REPLACE_EDITOR_COMMANDS)[number];
+/** Closed single-edit shape shared by registration, args validation, and the direct normalizer. */
+export declare const hashlineEditEntrySchema: z.ZodObject<{
+    op: z.ZodEnum<{
+        replace: "replace";
+        replace_range: "replace_range";
+        append: "append";
+        prepend: "prepend";
+    }>;
+    pos: z.ZodOptional<z.ZodString>;
+    end: z.ZodOptional<z.ZodString>;
+    lines: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString, z.ZodNull]>;
+}, z.core.$strip>;
+/** Schema-derived shape of one raw hash-anchored edit entry. */
+export type RawHashlineEditEntry = z.infer<typeof hashlineEditEntrySchema>;
+/** Registered raw argument map for hashline_edit (single source of the tool surface). */
+export declare const hashlineEditArgs: {
+    filePath: z.ZodString;
+    delete: z.ZodOptional<z.ZodBoolean>;
+    rename: z.ZodOptional<z.ZodString>;
+    edits: z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            replace: "replace";
+            replace_range: "replace_range";
+            append: "append";
+            prepend: "prepend";
+        }>;
+        pos: z.ZodOptional<z.ZodString>;
+        end: z.ZodOptional<z.ZodString>;
+        lines: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString, z.ZodNull]>;
+    }, z.core.$strip>>;
+};
+declare const hashlineEditArgsObject: z.ZodObject<{
+    filePath: z.ZodString;
+    delete: z.ZodOptional<z.ZodBoolean>;
+    rename: z.ZodOptional<z.ZodString>;
+    edits: z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            replace: "replace";
+            replace_range: "replace_range";
+            append: "append";
+            prepend: "prepend";
+        }>;
+        pos: z.ZodOptional<z.ZodString>;
+        end: z.ZodOptional<z.ZodString>;
+        lines: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString, z.ZodNull]>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** hashline_edit argument shape, single-sourced from the registered schema. */
+export type HashlineEditToolArgs = z.infer<typeof hashlineEditArgsObject>;
+/** Registered raw argument map for str_replace_editor (single source of the tool surface). */
+export declare const strReplaceEditorArgs: {
+    command: z.ZodEnum<{
+        view: "view";
+        create: "create";
+        str_replace: "str_replace";
+        insert: "insert";
+    }>;
+    path: z.ZodString;
+    file_text: z.ZodOptional<z.ZodString>;
+    old_str: z.ZodOptional<z.ZodString>;
+    new_str: z.ZodOptional<z.ZodString>;
+    insert_line: z.ZodOptional<z.ZodNumber>;
+    view_range: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+};
+declare const strReplaceEditorArgsObject: z.ZodObject<{
+    command: z.ZodEnum<{
+        view: "view";
+        create: "create";
+        str_replace: "str_replace";
+        insert: "insert";
+    }>;
+    path: z.ZodString;
+    file_text: z.ZodOptional<z.ZodString>;
+    old_str: z.ZodOptional<z.ZodString>;
+    new_str: z.ZodOptional<z.ZodString>;
+    insert_line: z.ZodOptional<z.ZodNumber>;
+    view_range: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}, z.core.$strip>;
+/** str_replace_editor argument shape, single-sourced from the registered schema. */
+export type StrReplaceEditorToolArgs = z.infer<typeof strReplaceEditorArgsObject>;
+/** Concrete filediff metadata envelope published after a successful hashline edit. */
+export declare const hashlineEditFilediffSchema: z.ZodObject<{
+    file: z.ZodString;
+    path: z.ZodString;
+    filePath: z.ZodString;
+    before: z.ZodString;
+    after: z.ZodString;
+}, z.core.$strip>;
+/** Concrete success metadata envelope for hashline_edit (known fields, no blanket records). */
+export declare const hashlineEditMetadataSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    path: z.ZodString;
+    file: z.ZodString;
+    noopEdits: z.ZodNumber;
+    deduplicatedEdits: z.ZodNumber;
+    firstChangedLine: z.ZodOptional<z.ZodNumber>;
+    editMode: z.ZodEnum<{
+        hashline_edit: "hashline_edit";
+        str_replace_editor: "str_replace_editor";
+        edit: "edit";
+        apply_patch: "apply_patch";
+    }>;
+    providerID: z.ZodOptional<z.ZodString>;
+    modelID: z.ZodOptional<z.ZodString>;
+    filediff: z.ZodObject<{
+        file: z.ZodString;
+        path: z.ZodString;
+        filePath: z.ZodString;
+        before: z.ZodString;
+        after: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Concrete success metadata envelope for str_replace_editor. */
+export declare const strReplaceEditorMetadataSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    path: z.ZodString;
+    file: z.ZodString;
+    editMode: z.ZodEnum<{
+        hashline_edit: "hashline_edit";
+        str_replace_editor: "str_replace_editor";
+        edit: "edit";
+        apply_patch: "apply_patch";
+    }>;
+    providerID: z.ZodOptional<z.ZodString>;
+    modelID: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Closed ok/error result schema for str_replace_editor producer/test checks.
+ * This is never applied as a throw-after-side-effect execute wrapper.
+ */
+export declare const strReplaceEditorResultSchema: z.ZodUnion<readonly [z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    output: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    ok: z.ZodLiteral<false>;
+    error: z.ZodString;
+}, z.core.$strip>]>;
+/** Str editor ok/error result shape (producer/test contract). */
+export type StrReplaceEditorResult = z.infer<typeof strReplaceEditorResultSchema>;
+/** Owned contract for hashline_edit. */
+export declare const hashlineEditContract: OwnedToolContract<{
+    filePath: z.ZodString;
+    delete: z.ZodOptional<z.ZodBoolean>;
+    rename: z.ZodOptional<z.ZodString>;
+    edits: z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            replace: "replace";
+            replace_range: "replace_range";
+            append: "append";
+            prepend: "prepend";
+        }>;
+        pos: z.ZodOptional<z.ZodString>;
+        end: z.ZodOptional<z.ZodString>;
+        lines: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString, z.ZodNull]>;
+    }, z.core.$strip>>;
+}>;
+/** Owned contract for str_replace_editor. */
+export declare const strReplaceEditorContract: OwnedToolContract<{
+    command: z.ZodEnum<{
+        view: "view";
+        create: "create";
+        str_replace: "str_replace";
+        insert: "insert";
+    }>;
+    path: z.ZodString;
+    file_text: z.ZodOptional<z.ZodString>;
+    old_str: z.ZodOptional<z.ZodString>;
+    new_str: z.ZodOptional<z.ZodString>;
+    insert_line: z.ZodOptional<z.ZodNumber>;
+    view_range: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+}>;
+/** Owned contracts for both edit tools (input to the owned definition/pre-execute adapters). */
+export declare const editToolContracts: readonly OwnedToolContract<ZodRawShape>[];
+/** Successful parsed hashline args or bounded structural/branch issues. */
+export type HashlineEditValidation = {
+    ok: true;
+    data: HashlineEditToolArgs;
+} | {
+    ok: false;
+    issues: readonly ContractIssue[];
+};
+/**
+ * Closed single-edit shape validation reused by the direct normalizer.
+ * Rejects unknown properties, malformed provided optional types, a provided
+ * non-canonical operation name, and (through the shared schema) missing
+ * op/lines. Blank `pos`/`end` are valid strings here and are rejected by the
+ * normalizer's anchor step so blank-versus-absent stays distinguishable.
+ */
+export declare function validateRawHashlineEditEntry(raw: unknown, index: number): {
+    ok: true;
+    data: RawHashlineEditEntry;
+} | {
+    ok: false;
+    issues: readonly ContractIssue[];
+};
+/**
+ * Strict structural plus args-only branch validation for hashline_edit.
+ * Unknown keys, enums, and nested shapes fail first; then non-empty paths,
+ * delete/rename/edits combinations, and per-operation anchor requirements are
+ * enforced. Current-file anchor validation, literal payload rejection, and
+ * creation remain in the normalizer/executor and stay authoritative.
+ */
+export declare function validateHashlineEditToolInput(raw: unknown): HashlineEditValidation;
+/** Successful parsed str editor args or bounded structural/command issues. */
+export type StrReplaceEditorValidation = {
+    ok: true;
+    data: StrReplaceEditorToolArgs;
+} | {
+    ok: false;
+    issues: readonly ContractIssue[];
+};
+/**
+ * Strict structural plus command-specific validation for str_replace_editor.
+ * Unknown keys, enums, and types fail first; then recognized fields that the
+ * selected command does not consume are rejected rather than dropped, the
+ * command's required fields are enforced, and view_range is required to be an
+ * exact two-integer range. Path existence, directory checks, the file-length
+ * insert bound, exact-match behavior, and freshness checks remain in the editor.
+ */
+export declare function validateStrReplaceEditorToolInput(raw: unknown): StrReplaceEditorValidation;
+export {};