@aria-cli/tools 1.0.8 → 1.0.10

package/tests/integration/headless-control-contract.integration.test.ts

@@ -1,153 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  HEADLESS_OPERATION_NAMES,
-  HEADLESS_OPERATION_SCHEMAS,
-  HEADLESS_STREAMING_OPERATION_NAMES,
-  HeadlessClientFrameSchema,
-  HeadlessEventSchema,
-  HeadlessInteractionRequestSchema,
-  HeadlessInteractionResponseSchema,
-  HeadlessOperationNameSchema,
-  HeadlessRequestSchema,
-  HeadlessResultSchema,
-  ResumeRunRequestSchema,
-  RunRequestSchema,
-  RunResultSchema,
-  RuntimeRunEventSchema,
-} from "../../src/index.js";
-
-describe("headless control contract", () => {
-  it("exports the canonical operation inventory", () => {
-    expect(HEADLESS_OPERATION_NAMES).toContain("run.start");
-    expect(HEADLESS_OPERATION_NAMES).toContain("session.load");
-    expect(HEADLESS_OPERATION_NAMES).toContain("daemon.status");
-    expect(HEADLESS_OPERATION_NAMES).toContain("hook.extract");
-    expect(HEADLESS_OPERATION_NAMES).toContain("interaction.respond");
-    expect(HEADLESS_OPERATION_NAMES).toContain("peer.list_nearby");
-    expect(HEADLESS_OPERATION_NAMES).toContain("message.send");
-    expect(HeadlessOperationNameSchema.safeParse("run.start").success).toBe(true);
-    expect(HeadlessOperationNameSchema.safeParse("not.real").success).toBe(false);
-  });
-
-  it("reuses the existing runtime schemas for run.start and run.resume", () => {
-    expect(
-      HEADLESS_OPERATION_SCHEMAS["run.start"].input.safeParse({
-        task: "hello",
-        sessionId: "session-1",
-        requestedModel: "opus-4.6",
-      }).success,
-    ).toBe(true);
-    expect(RunRequestSchema.safeParse({ task: "hello", sessionId: "session-1" }).success).toBe(
-      false,
-    );
-    expect(HEADLESS_OPERATION_SCHEMAS["run.start"].result).toBe(RunResultSchema);
-    expect(HEADLESS_OPERATION_SCHEMAS["run.start"].event).toBe(RuntimeRunEventSchema);
-    expect(
-      HEADLESS_OPERATION_SCHEMAS["run.resume"].input.safeParse({
-        sessionId: "session-1",
-        requestedModel: "opus-4.6",
-        state: {
-          input: "resume",
-          messages: [],
-          turnNumber: 1,
-          options: {},
-        },
-      }).success,
-    ).toBe(true);
-    expect(
-      ResumeRunRequestSchema.safeParse({
-        sessionId: "session-1",
-        state: {
-          input: "resume",
-          messages: [],
-          turnNumber: 1,
-          options: {},
-        },
-      }).success,
-    ).toBe(false);
-    expect(HEADLESS_STREAMING_OPERATION_NAMES).toEqual(["run.start"]);
-  });
-
-  it("parses canonical request, event, result, and interaction envelopes", () => {
-    expect(
-      HeadlessRequestSchema.parse({
-        kind: "request",
-        requestId: "req-1",
-        op: "run.start",
-        input: { task: "hello" },
-      }),
-    ).toMatchObject({ kind: "request", requestId: "req-1", op: "run.start" });
-
-    expect(
-      HeadlessEventSchema.parse({
-        kind: "event",
-        requestId: "req-1",
-        seq: 0,
-        op: "run.start",
-        event: { type: "text_delta", content: "hi" },
-      }),
-    ).toMatchObject({ kind: "event", requestId: "req-1", op: "run.start" });
-
-    expect(
-      HeadlessResultSchema.parse({
-        kind: "result",
-        requestId: "parse-1",
-        op: "run.start",
-        ok: false,
-        error: { code: "PARSE_ERROR", message: "Malformed JSON input" },
-      }),
-    ).toMatchObject({ kind: "result", requestId: "parse-1", op: "run.start", ok: false });
-
-    expect(
-      HeadlessResultSchema.parse({
-        kind: "result",
-        requestId: "req-1",
-        op: "run.start",
-        ok: true,
-        result: { success: true, output: "done" },
-      }),
-    ).toMatchObject({ kind: "result", requestId: "req-1", op: "run.start", ok: true });
-
-    expect(
-      HeadlessInteractionRequestSchema.parse({
-        kind: "interaction.required",
-        requestId: "req-2",
-        interactionId: "int-1",
-        source: "run",
-        interaction: {
-          kind: "questionnaire",
-          questions: [{ question: "Approve?" }],
-        },
-      }),
-    ).toMatchObject({ kind: "interaction.required", interactionId: "int-1", source: "run" });
-
-    expect(
-      HeadlessInteractionResponseSchema.parse({
-        kind: "interaction.respond",
-        requestId: "req-2",
-        interactionId: "int-1",
-        response: { kind: "questionnaire", answers: ["yes"] },
-      }),
-    ).toMatchObject({ kind: "interaction.respond", interactionId: "int-1" });
-  });
-
-  it("rejects mismatched operation payloads", () => {
-    expect(
-      HeadlessRequestSchema.safeParse({
-        kind: "request",
-        requestId: "req-bad",
-        op: "run.start",
-        input: {},
-      }).success,
-    ).toBe(false);
-
-    expect(
-      HeadlessClientFrameSchema.safeParse({
-        kind: "interaction.respond",
-        requestId: "req-bad",
-        interactionId: "int-1",
-        response: { kind: "selection" },
-      }).success,
-    ).toBe(false);
-  });
-});

package/tests/integration/memory-tool-schema-parity.integration.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createToolRegistry, getCoreTool } from "../../src/index.js";
-
-describe("Memory tool schema/runtime parity", () => {
-  it("[CRITICAL] recall schema should NOT have tags (intentionally removed)", () => {
-    const recall = getCoreTool("recall");
-    expect(recall).toBeDefined();
-
-    const schema = recall!.parameters as {
-      properties?: Record<string, unknown>;
-    };
-    expect(schema.properties).toBeDefined();
-    expect(schema.properties).not.toHaveProperty("tags");
-  });
-
-  it("[CRITICAL] registry ToolInfo should NOT expose recall.tags", () => {
-    const registry = createToolRegistry();
-    const recallInfo = registry.getToolInfos().find((t) => t.name === "recall");
-    expect(recallInfo).toBeDefined();
-    expect(recallInfo!.parameters.map((p) => p.name)).not.toContain("tags");
-  });
-
-  it("🔴 forget schema should not advertise unsupported query parameter", () => {
-    const forget = getCoreTool("forget");
-    expect(forget).toBeDefined();
-
-    const schema = forget!.parameters as {
-      properties?: Record<string, unknown>;
-    };
-    expect(schema.properties).toBeDefined();
-    expect(schema.properties).not.toHaveProperty("query");
-  });
-
-  it("🔴 registry ToolInfo should not expose forget.query", () => {
-    const registry = createToolRegistry();
-    const forgetInfo = registry.getToolInfos().find((t) => t.name === "forget");
-    expect(forgetInfo).toBeDefined();
-    expect(forgetInfo!.parameters.map((p) => p.name)).not.toContain("query");
-  });
-
-  it("reflect schema should have summary parameter (not topic)", () => {
-    const reflect = getCoreTool("reflect");
-    expect(reflect).toBeDefined();
-
-    const schema = reflect!.parameters as {
-      properties?: Record<string, unknown>;
-      required?: string[];
-    };
-    expect(schema.properties).toBeDefined();
-    expect(schema.properties).toHaveProperty("summary");
-    expect(schema.properties).not.toHaveProperty("topic");
-    expect(schema.required).toContain("summary");
-  });
-
-  it("recall_knowledge schema should have kind and limit instead of depth", () => {
-    const rk = getCoreTool("recall_knowledge");
-    expect(rk).toBeDefined();
-
-    const schema = rk!.parameters as {
-      properties?: Record<string, unknown>;
-    };
-    expect(schema.properties).toBeDefined();
-    expect(schema.properties).not.toHaveProperty("depth");
-    expect(schema.properties).toHaveProperty("kind");
-    expect(schema.properties).toHaveProperty("limit");
-  });
-});