@agent-native/pinpoint 0.1.12 → 0.1.14

package/dist/index.browser.js

@@ -18,7 +18,7 @@ import {
   mountPinpoint,
   registerAdapter,
   unmountPinpoint
-} from "./chunk-HC724C43.js";
+} from "./chunk-P4AZ2AAL.js";
 import {
   formatPinsForAgent,
   formatQueueForAgent,

package/dist/react.js

@@ -1,7 +1,7 @@
 "use client";
 import {
   mountPinpoint
-} from "./chunk-HC724C43.js";
+} from "./chunk-P4AZ2AAL.js";
 
 // src/react.tsx
 import { useEffect } from "react";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/pinpoint",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Visual feedback and annotation tool for agent-native web applications",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {
@@ -21,6 +21,10 @@
     ".agents"
   ],
   "type": "module",
+  "sideEffects": [
+    "dist/cli.js",
+    "dist/index.browser.js"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -68,7 +72,7 @@
     "typescript-7": "npm:typescript@^7.0.2",
     "vite-plugin-solid": "^2.11.0",
     "vitest": "^4.1.5",
-    "@agent-native/core": "0.97.0"
+    "@agent-native/core": "0.109.4"
   },
   "peerDependencies": {
     "@agent-native/core": ">=0.8.0",

package/src/scripts/create-pin.spec.ts

@@ -0,0 +1,117 @@
+// @agent-native/pinpoint — create-pin script tests
+// MIT License
+//
+// createPin() always constructs `new FileStore()` with no explicit data
+// directory, which resolves the storage path relative to `process.cwd()`.
+// To exercise it against a throwaway directory (matching file-store.spec.ts's
+// temp-dir style) without touching source, each test chdirs into a fresh
+// temp directory before invoking the script and restores the original cwd
+// afterward.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { FileStore } from "../storage/file-store.js";
+import createPin from "./create-pin.js";
+
+const tmpRoots: string[] = [];
+const originalCwd = process.cwd();
+
+afterEach(() => {
+  process.chdir(originalCwd);
+  for (const root of tmpRoots.splice(0)) {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+function chdirTmp(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pinpoint-create-pin-"));
+  tmpRoots.push(root);
+  process.chdir(root);
+  return root;
+}
+
+describe("create-pin script", () => {
+  it("writes a new pin with the fields derived from CLI args", async () => {
+    const root = chdirTmp();
+
+    await createPin([
+      "--pageUrl",
+      "https://example.com/dashboard",
+      "--selector",
+      ".card:nth-child(2)",
+      "--comment",
+      "This card is misaligned",
+      "--author",
+      "steve",
+    ]);
+
+    const store = new FileStore(path.join(root, "data/pins"));
+    const pins = await store.list();
+
+    expect(pins).toHaveLength(1);
+    const pin = pins[0]!;
+    expect(pin.pageUrl).toBe("https://example.com/dashboard");
+    expect(pin.comment).toBe("This card is misaligned");
+    expect(pin.author).toBe("steve");
+    expect(pin.element.selector).toBe(".card:nth-child(2)");
+    expect(pin.element.tagName).toBe("unknown");
+    expect(pin.status).toEqual({
+      state: "open",
+      changedAt: pin.status.changedAt,
+      changedBy: "agent",
+    });
+    expect(pin.createdAt).toBe(pin.updatedAt);
+    expect(pin.id).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
+    );
+  });
+
+  it("omits author when not provided", async () => {
+    const root = chdirTmp();
+
+    await createPin([
+      "--pageUrl",
+      "https://example.com",
+      "--selector",
+      "#hero",
+      "--comment",
+      "note",
+    ]);
+
+    const store = new FileStore(path.join(root, "data/pins"));
+    const [pin] = await store.list();
+    expect(pin!.author).toBeUndefined();
+  });
+
+  it("rejects when --pageUrl is missing", async () => {
+    chdirTmp();
+    await expect(
+      createPin(["--selector", "#hero", "--comment", "note"]),
+    ).rejects.toThrow("--pageUrl is required");
+  });
+
+  it("rejects when --selector is missing", async () => {
+    chdirTmp();
+    await expect(
+      createPin(["--pageUrl", "https://example.com", "--comment", "note"]),
+    ).rejects.toThrow("--selector is required");
+  });
+
+  it("rejects when --comment is missing", async () => {
+    chdirTmp();
+    await expect(
+      createPin(["--pageUrl", "https://example.com", "--selector", "#hero"]),
+    ).rejects.toThrow("--comment is required");
+  });
+
+  it("checks pageUrl before selector when both are missing", async () => {
+    chdirTmp();
+    await expect(createPin(["--comment", "note"])).rejects.toThrow(
+      "--pageUrl is required",
+    );
+  });
+});

package/src/scripts/delete-pin.spec.ts

@@ -0,0 +1,100 @@
+// @agent-native/pinpoint — delete-pin script tests
+// MIT License
+//
+// Same temp-dir-via-chdir approach as create-pin.spec.ts / update-pin.spec.ts,
+// since deletePin() always constructs `new FileStore()` with the default
+// `data/pins` path resolved against `process.cwd()`.
+
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { FileStore } from "../storage/file-store.js";
+import type { Pin } from "../types/index.js";
+import deletePin from "./delete-pin.js";
+
+const tmpRoots: string[] = [];
+const originalCwd = process.cwd();
+
+afterEach(() => {
+  process.chdir(originalCwd);
+  for (const root of tmpRoots.splice(0)) {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+function chdirTmp(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pinpoint-delete-pin-"));
+  tmpRoots.push(root);
+  process.chdir(root);
+  return root;
+}
+
+function makePin(overrides: Partial<Pin> = {}): Pin {
+  const now = new Date().toISOString();
+  return {
+    id: randomUUID(),
+    pageUrl: "https://example.com/page",
+    createdAt: now,
+    updatedAt: now,
+    comment: "note",
+    element: {
+      tagName: "DIV",
+      classNames: [],
+      selector: ".card",
+      boundingRect: { x: 0, y: 0, width: 10, height: 10 },
+    },
+    status: { state: "open", changedAt: now },
+    ...overrides,
+  };
+}
+
+describe("delete-pin script", () => {
+  it("removes the pin file for the given id", async () => {
+    const root = chdirTmp();
+    const store = new FileStore(path.join(root, "data/pins"));
+    const pin = makePin();
+    await store.save(pin);
+    expect(await store.list()).toHaveLength(1);
+
+    await deletePin(["--id", pin.id]);
+
+    expect(await store.list()).toEqual([]);
+  });
+
+  it("leaves other pins untouched", async () => {
+    const root = chdirTmp();
+    const store = new FileStore(path.join(root, "data/pins"));
+    const pinA = makePin();
+    const pinB = makePin();
+    await store.save(pinA);
+    await store.save(pinB);
+
+    await deletePin(["--id", pinA.id]);
+
+    const remaining = await store.list();
+    expect(remaining).toHaveLength(1);
+    expect(remaining[0]!.id).toBe(pinB.id);
+  });
+
+  it("rejects when --id is missing", async () => {
+    chdirTmp();
+    await expect(deletePin([])).rejects.toThrow("--id is required");
+  });
+
+  it("resolves without throwing when the id does not exist", async () => {
+    chdirTmp();
+    await expect(deletePin(["--id", randomUUID()])).resolves.toBeUndefined();
+  });
+
+  it("resolves without throwing for a malformed id (FileStore.delete() swallows the 'Invalid pin ID' error internally)", async () => {
+    // Unlike update-pin, FileStore.delete() computes the (validated) file
+    // path *inside* its own try/catch, so an invalid id is caught silently
+    // rather than propagating — this documents that asymmetry.
+    chdirTmp();
+    await expect(deletePin(["--id", "../escape"])).resolves.toBeUndefined();
+  });
+});

package/src/scripts/update-pin.spec.ts

@@ -0,0 +1,138 @@
+// @agent-native/pinpoint — update-pin script tests
+// MIT License
+//
+// Same temp-dir-via-chdir approach as create-pin.spec.ts, since updatePin()
+// always constructs `new FileStore()` with the default `data/pins` path
+// resolved against `process.cwd()`.
+
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { FileStore } from "../storage/file-store.js";
+import type { Pin } from "../types/index.js";
+import updatePin from "./update-pin.js";
+
+const tmpRoots: string[] = [];
+const originalCwd = process.cwd();
+
+afterEach(() => {
+  process.chdir(originalCwd);
+  for (const root of tmpRoots.splice(0)) {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});
+
+function chdirTmp(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "pinpoint-update-pin-"));
+  tmpRoots.push(root);
+  process.chdir(root);
+  return root;
+}
+
+function makePin(overrides: Partial<Pin> = {}): Pin {
+  const now = new Date().toISOString();
+  return {
+    id: randomUUID(),
+    pageUrl: "https://example.com/page",
+    createdAt: now,
+    updatedAt: now,
+    comment: "original comment",
+    element: {
+      tagName: "DIV",
+      classNames: ["card"],
+      selector: ".card",
+      boundingRect: { x: 0, y: 0, width: 10, height: 10 },
+    },
+    status: { state: "open", changedAt: now, changedBy: "user" },
+    ...overrides,
+  };
+}
+
+describe("update-pin script", () => {
+  it("updates the comment and bumps updatedAt, leaving status untouched", async () => {
+    const root = chdirTmp();
+    const store = new FileStore(path.join(root, "data/pins"));
+    const pin = makePin();
+    await store.save(pin);
+
+    await updatePin(["--id", pin.id, "--comment", "revised comment"]);
+
+    const [updated] = await store.list();
+    expect(updated!.comment).toBe("revised comment");
+    expect(updated!.updatedAt).not.toBe(pin.updatedAt);
+    expect(updated!.status).toEqual(pin.status);
+  });
+
+  it("updates status and always stamps changedBy as 'agent', overwriting any prior value", async () => {
+    const root = chdirTmp();
+    const store = new FileStore(path.join(root, "data/pins"));
+    // Default fixture status already has changedBy: "user" — confirms the
+    // script always overwrites it with "agent" rather than preserving it.
+    const pin = makePin();
+    await store.save(pin);
+
+    await updatePin(["--id", pin.id, "--status", "resolved"]);
+
+    const [updated] = await store.list();
+    expect(updated!.status.state).toBe("resolved");
+    expect(updated!.status.changedBy).toBe("agent");
+    expect(updated!.comment).toBe(pin.comment); // untouched
+  });
+
+  it("can update comment and status together in one call", async () => {
+    const root = chdirTmp();
+    const store = new FileStore(path.join(root, "data/pins"));
+    const pin = makePin();
+    await store.save(pin);
+
+    await updatePin([
+      "--id",
+      pin.id,
+      "--comment",
+      "both changed",
+      "--status",
+      "dismissed",
+    ]);
+
+    const [updated] = await store.list();
+    expect(updated!.comment).toBe("both changed");
+    expect(updated!.status.state).toBe("dismissed");
+  });
+
+  it("rejects when --id is missing", async () => {
+    chdirTmp();
+    await expect(updatePin(["--comment", "x"])).rejects.toThrow(
+      "--id is required",
+    );
+  });
+
+  it("rejects when neither --comment nor --status is given", async () => {
+    chdirTmp();
+    await expect(updatePin(["--id", randomUUID()])).rejects.toThrow(
+      "--comment or --status is required",
+    );
+  });
+
+  it("resolves without writing a file when the pin id does not exist (FileStore.update() is a silent no-op)", async () => {
+    const root = chdirTmp();
+    const missingId = randomUUID();
+
+    await expect(
+      updatePin(["--id", missingId, "--comment", "irrelevant"]),
+    ).resolves.toBeUndefined();
+
+    const store = new FileStore(path.join(root, "data/pins"));
+    expect(await store.list()).toEqual([]);
+  });
+
+  it("rejects with 'Invalid pin ID' for a malformed id (unlike delete, FileStore.update does not swallow this)", async () => {
+    chdirTmp();
+    await expect(
+      updatePin(["--id", "../escape", "--comment", "x"]),
+    ).rejects.toThrow(/Invalid pin ID/);
+  });
+});