@ocis/myagent-cli 0.2.0

package/dist/tools/types.d.ts

@@ -0,0 +1,85 @@
+import type { TodoStore } from "../agent/todo.js";
+import type { IntegrationClient } from "../protocol/client.js";
+export interface JsonSchema {
+    type: "object";
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [key: string]: unknown;
+}
+export interface ToolDefinition {
+    type: "function";
+    function: {
+        name: string;
+        description: string;
+        parameters: JsonSchema;
+    };
+}
+export interface ApprovalRequest {
+    tool: string;
+    summary: string;
+    /** True when the call reaches outside the workspace (AUTO asks for these). */
+    outsideWorkspace?: boolean;
+    /** Id of the tool call this approval is about (lets the UI ignore releases
+     *  of other calls in the same round). */
+    callId?: string;
+    /**
+     * The caller's per-CALL mutation verdict (`isMutatingCall`) — set for tools
+     * whose arguments decide it (transfer get vs put/list). The policy's plan
+     * check uses it instead of the name-based read-only list; omitted, it falls
+     * back to that list.
+     */
+    mutating?: boolean;
+}
+export interface ToolContext {
+    /** Workspace root — every relative path resolves against it. */
+    workspace: string;
+    /** Allow paths outside the workspace (--allow-outside). */
+    allowOutside: boolean;
+    /** Extra skill directories (--skills-dir). */
+    skillDirs: string[];
+    /** Aborted when the user interrupts the run (Esc / Ctrl+C). */
+    signal?: AbortSignal;
+    /** Shared todo list (local_update_todo). */
+    todos: TodoStore;
+    /** Integration API client (workspace transfers). Absent in tool unit tests. */
+    client?: IntegrationClient;
+}
+export interface ToolHandler {
+    definition: ToolDefinition;
+    /** Mutating tools require approval and are refused in plan mode. */
+    mutating: boolean;
+    /**
+     * Per-call override for `mutating` — for tools whose direction decides
+     * whether they touch the user's machine (e.g. transfer get vs put/list).
+     */
+    isMutating?: (args: Record<string, unknown>) => boolean;
+    /** One-line summary shown in the transcript / approval prompt. */
+    summarize: (args: Record<string, unknown>) => string;
+    /** Execute and return the text delivered to the model. */
+    run: (args: Record<string, unknown>, ctx: ToolContext) => Promise<string>;
+}
+/** Declarative spec accepted by {@link defineTool}. */
+export interface ToolSpec {
+    name: string;
+    description: string;
+    parameters: JsonSchema;
+    /** Defaults to false (read-only). */
+    mutating?: boolean;
+    /** Per-call mutation override (see {@link ToolHandler.isMutating}). */
+    isMutating?: (args: Record<string, unknown>) => boolean;
+    summarize: (args: Record<string, unknown>) => string;
+    run: (args: Record<string, unknown>, ctx: ToolContext) => Promise<string>;
+}
+export declare function defineTool(spec: ToolSpec): ToolHandler;
+/**
+ * Whether a call mutates the user's machine — the single definition behind
+ * plan-mode refusal, approval, replay-after-reconnect and read-only batching.
+ * Direction-aware tools decide per call (`isMutating`); unknown tools count as
+ * mutating so they serialize and are never replayed silently.
+ */
+export declare function isMutatingCall(handler: ToolHandler | undefined, args: Record<string, unknown>): boolean;
+/** Narrow an unknown argument value to a string, with a field-labelled error. */
+export declare function requireString(args: Record<string, unknown>, field: string): string;
+export declare function optionalString(args: Record<string, unknown>, field: string): string | undefined;
+export declare function optionalNumber(args: Record<string, unknown>, field: string): number | undefined;
+export declare function optionalBoolean(args: Record<string, unknown>, field: string): boolean | undefined;

package/dist/tools/types.js

@@ -0,0 +1,63 @@
+// ---------------------------------------------------------------------------
+// Client tool contracts.
+//
+// Tools execute on the user's machine (the CLI process), never on the server.
+// The server receives only the JSON-schema definitions; execution results are
+// sent back as tool_outputs. `mutating` drives approval and mode filtering.
+// ---------------------------------------------------------------------------
+export function defineTool(spec) {
+    return {
+        definition: {
+            type: "function",
+            function: { name: spec.name, description: spec.description, parameters: spec.parameters },
+        },
+        mutating: spec.mutating ?? false,
+        ...(spec.isMutating ? { isMutating: spec.isMutating } : {}),
+        summarize: spec.summarize,
+        run: spec.run,
+    };
+}
+/**
+ * Whether a call mutates the user's machine — the single definition behind
+ * plan-mode refusal, approval, replay-after-reconnect and read-only batching.
+ * Direction-aware tools decide per call (`isMutating`); unknown tools count as
+ * mutating so they serialize and are never replayed silently.
+ */
+export function isMutatingCall(handler, args) {
+    if (!handler)
+        return true;
+    return handler.isMutating?.(args) ?? handler.mutating;
+}
+/** Narrow an unknown argument value to a string, with a field-labelled error. */
+export function requireString(args, field) {
+    const value = args[field];
+    if (typeof value !== "string") {
+        throw new Error(`Invalid arguments: "${field}" must be a string.`);
+    }
+    return value;
+}
+export function optionalString(args, field) {
+    const value = args[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "string")
+        throw new Error(`Invalid arguments: "${field}" must be a string.`);
+    return value;
+}
+export function optionalNumber(args, field) {
+    const value = args[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`Invalid arguments: "${field}" must be a number.`);
+    }
+    return value;
+}
+export function optionalBoolean(args, field) {
+    const value = args[field];
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw new Error(`Invalid arguments: "${field}" must be a boolean.`);
+    return value;
+}

package/dist/ui/app.d.ts

@@ -0,0 +1,39 @@
+import type { IntegrationClient } from "../protocol/client.js";
+import type { AgentUsage } from "../protocol/types.js";
+import type { ToolRegistry } from "../tools/registry.js";
+import type { StoredConfig } from "../config.js";
+import { type AgentMode } from "../agent/modes.js";
+import { SessionIndex } from "../agent/sessions.js";
+import { type ApprovalMode } from "../approval/policy.js";
+export interface TuiOptions {
+    client: IntegrationClient;
+    registry: ToolRegistry;
+    config: StoredConfig;
+    sessionIndex: SessionIndex;
+    workspace: string;
+    allowOutside: boolean;
+    skillDirs: string[];
+    extraInstructions?: string;
+    noContextFiles?: boolean;
+    initialMode: AgentMode;
+    initialApproval: ApprovalMode;
+    initialThinking?: string;
+    /** Client-choice model for new sessions (from --model). */
+    initialModel?: string;
+    /** Positional CLI prompt, submitted as the first message of the session. */
+    initialPrompt?: string;
+    resumeThreadId?: string;
+    noLogo?: boolean;
+}
+/**
+ * Panel width: ~25% of the terminal, floored at a readable minimum. Grows
+ * with wide terminals instead of being capped, so the panel keeps its share
+ * as the window grows (the transcript already gets the larger part).
+ */
+export declare function sidebarWidth(columns: number): number;
+export declare function runTui(opts: TuiOptions): Promise<number>;
+/**
+ * Footer usage: `current` minus the pre-run `baseline`, so the status bar
+ * reports the current/last run instead of the session total.
+ */
+export declare function runUsageDelta(current: AgentUsage | null, baseline: AgentUsage | null): AgentUsage | null;