@inneranimalmedia/agentsam-sdk 2.6.7 → 2.6.8

package/packages/agentsam-goap/src/world.js

@@ -0,0 +1,202 @@
+import {
+  GOAP_SCHEMAS,
+  normalizeActionSpec,
+  normalizeBlackboard,
+  normalizeGoal,
+} from './contracts.js';
+import { goapInputError } from './errors.js';
+
+const TODO_TO_GOAL_STATUS = Object.freeze({
+  open: 'proposed',
+  running: 'active',
+  blocked: 'blocked',
+  complete: 'satisfied',
+  cancelled: 'cancelled',
+});
+
+const PRIORITY_COST = Object.freeze({
+  critical: 1,
+  high: 2,
+  medium: 3,
+  low: 4,
+});
+
+function clean(value) {
+  return value == null ? '' : String(value).trim();
+}
+
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function object(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function taskById(plan) {
+  return new Map(array(plan?.tasks).map((task) => [task.id, task]));
+}
+
+function blockersFor(plan, task) {
+  const byId = taskById(plan);
+  return array(task?.metadata?.depends_on)
+    .map((id) => byId.get(id) || { id, title: null, status: 'missing' })
+    .filter((dependency) => dependency.status !== 'complete')
+    .map((dependency) => ({
+      id: dependency.id,
+      title: dependency.title || null,
+      status: dependency.status,
+    }));
+}
+
+export function projectPlanActions(plan = {}) {
+  const available = [];
+  const blocked = [];
+
+  for (const task of array(plan.tasks)) {
+    if (task.status !== 'open') continue;
+    const blockers = blockersFor(plan, task);
+    const action = {
+      id: task.id,
+      title: task.title,
+      status: task.status,
+      spec: normalizeActionSpec({
+        preconditions: array(task.metadata?.depends_on).map((todoId) => ({
+          fact: 'todo.complete',
+          todo_id: todoId,
+          value: true,
+        })),
+        effects: [{
+          fact: 'todo.complete',
+          todo_id: task.id,
+          value: true,
+        }],
+        cost: PRIORITY_COST[task.priority] ?? 3,
+        metadata: {
+          kind: task.metadata?.kind || 'work',
+          priority: task.priority || 'medium',
+          sort_order: Number(task.sort_order ?? 50),
+        },
+      }),
+    };
+
+    if (blockers.length) blocked.push({ ...action, blockers });
+    else available.push(action);
+  }
+
+  return { available, blocked };
+}
+
+export function projectGoapWorld({
+  repository = {},
+  plan,
+  activeTodo = null,
+  actions = null,
+  knowledge = {},
+  evidence = null,
+  accountId = null,
+  revision = 1,
+  updatedAt = null,
+} = {}) {
+  const repositoryId = clean(repository.repository_id ?? repository.repositoryId);
+  if (!repositoryId) {
+    throw goapInputError('repository.repository_id is required for GOAP world projection', {
+      stage: 'project_world',
+      details: { field: 'repository.repository_id' },
+    });
+  }
+  if (!plan?.id) {
+    throw goapInputError('plan.id is required for GOAP world projection', {
+      stage: 'project_world',
+      details: { field: 'plan.id' },
+    });
+  }
+
+  const projectedActions = actions || projectPlanActions(plan);
+  const todo = activeTodo || null;
+  const goalId = todo?.id || plan.id;
+  const goalTitle = todo?.title || plan.title || plan.id;
+  const goalStatus = todo
+    ? (TODO_TO_GOAL_STATUS[todo.status] || 'proposed')
+    : (Number(plan.tasks_done || 0) === Number(plan.tasks_total || -1) ? 'satisfied' : 'active');
+
+  const state = {
+    plan: {
+      id: plan.id,
+      title: plan.title || null,
+      status: plan.status || null,
+      tasks_done: Number(plan.tasks_done || 0),
+      tasks_total: Number(plan.tasks_total || array(plan.tasks).length),
+    },
+    todo: todo ? {
+      id: todo.id,
+      title: todo.title || null,
+      status: todo.status || null,
+      priority: todo.priority || null,
+      kind: todo.metadata?.kind || 'work',
+      depends_on: array(todo.metadata?.depends_on),
+      acceptance: array(todo.metadata?.acceptance),
+      evidence: array(todo.metadata?.evidence),
+    } : null,
+    repository: {
+      repository_id: repositoryId,
+      branch: repository.branch || null,
+      revision_sha: repository.revision_sha || repository.revisionSha || null,
+      dirty: repository.dirty ?? null,
+      merkle_root: repository.merkle_root || null,
+    },
+    knowledge: { ...object(knowledge) },
+    actions: projectedActions,
+    evidence: evidence || null,
+  };
+
+  const blackboard = normalizeBlackboard({
+    id: 'world:' + repositoryId,
+    account_id: clean(accountId) || null,
+    repository_id: repositoryId,
+    current_goal_id: goalId,
+    state,
+    revision,
+    locked_by: 'project_local_plan',
+    checkpoint_sha: repository.revision_sha || repository.revisionSha || null,
+    last_action: 'world_snapshot_projected',
+    updated_at: updatedAt,
+  });
+
+  const goal = normalizeGoal({
+    id: goalId,
+    account_id: clean(accountId),
+    repository_id: repositoryId,
+    title: goalTitle,
+    goal_status: goalStatus,
+    priority: todo?.priority || null,
+    spec: {
+      desired: [{
+        fact: todo ? 'todo.complete' : 'plan.complete',
+        [todo ? 'todo_id' : 'plan_id']: goalId,
+        value: true,
+      }],
+      constraints: array(todo?.metadata?.depends_on).map((todoId) => ({
+        fact: 'todo.complete',
+        todo_id: todoId,
+        value: true,
+      })),
+      metadata: {
+        source: 'project_local_plan',
+        plan_id: plan.id,
+        todo_id: todo?.id || null,
+      },
+    },
+    updated_at: updatedAt,
+  });
+
+  return {
+    schema: GOAP_SCHEMAS.world,
+    source: 'project_local_plan',
+    repository_id: repositoryId,
+    blackboard,
+    goal,
+    actions: projectedActions,
+    evidence: evidence || null,
+  };
+}

package/packages/agentsam-goap/test/goap-control-plane.test.mjs

@@ -0,0 +1,245 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { DatabaseSync } from 'node:sqlite';
+import {
+  AgentSamError,
+  ERROR_REASON,
+  planRecovery,
+} from '@inneranimalmedia/agentsam-errors';
+import {
+  GOAP_SCHEMAS,
+  MemoryGoapAdapter,
+  createD1SqliteGoapAdapter,
+  createGoapControlPlane,
+  goalStatusFromTicket,
+  ticketStatusFromGoal,
+} from '../src/index.js';
+
+const scope = {
+  account_id: 'acct_test',
+  repository_id: 'github:example/repo',
+  workspace_id: 'ws_test',
+};
+
+test('status mapping preserves database statuses while exposing logical GOAP states', () => {
+  assert.equal(goalStatusFromTicket('backlog'), 'proposed');
+  assert.equal(goalStatusFromTicket('in_review'), 'verifying');
+  assert.equal(ticketStatusFromGoal('satisfied'), 'shipped');
+});
+
+test('memory adapter atomically activates goal with CAS and append-only cursor', async () => {
+  const adapter = new MemoryGoapAdapter({
+    blackboards: [{
+      ...scope,
+      id: 'bb_1',
+      current_goal_id: null,
+      state: { build: { valid: false } },
+      revision: 4,
+    }],
+    goals: [{
+      ...scope,
+      id: 'tkt_1',
+      title: 'Make build valid',
+      status: 'backlog',
+      goal_spec_json: { desired: [{ fact: 'build.valid', op: 'eq', value: true }] },
+    }],
+  });
+
+  const service = createGoapControlPlane({ ports: adapter.ports(), clock: () => 100 });
+  const activated = await service.activateGoal({
+    scope,
+    goalId: 'tkt_1',
+    expectedRevision: 4,
+    actor: { type: 'test', id: 'runner' },
+  });
+
+  assert.equal(activated.blackboard.revision, 5);
+  assert.equal(activated.blackboard.current_goal_id, 'tkt_1');
+  assert.equal(activated.goal.status, 'active');
+  assert.equal(activated.events.length, 1);
+  assert.equal(activated.events[0].type, 'goal.activated');
+  assert.equal(activated.events[0].payload.blackboard_revision, 5);
+  assert.match(activated.events[0].cursor, /^memory:/);
+
+  await assert.rejects(
+    service.activateGoal({ scope, goalId: 'tkt_1', expectedRevision: 4 }),
+    (error) => {
+      assert.equal(error instanceof AgentSamError, true);
+      assert.equal(error.reason, ERROR_REASON.STALE_VERSION);
+      assert.equal(error.code, 'ABORTED');
+      assert.equal(error.envelope.tool, 'goap');
+      assert.equal(planRecovery(error.envelope).disposition, 'retry');
+      return true;
+    },
+  );
+});
+
+function d1Like(db) {
+  return {
+    prepare(sql) {
+      const statement = db.prepare(sql);
+      return {
+        bind(...values) {
+          return {
+            async first() {
+              return statement.get(...values) ?? null;
+            },
+            async all() {
+              return { results: statement.all(...values) };
+            },
+            async run() {
+              return statement.run(...values);
+            },
+          };
+        },
+      };
+    },
+    async batch(statements) {
+      db.exec('BEGIN IMMEDIATE');
+      try {
+        const results = [];
+        for (const statement of statements) results.push(await statement.run());
+        db.exec('COMMIT');
+        return results;
+      } catch (error) {
+        try { db.exec('ROLLBACK'); } catch {}
+        throw error;
+      }
+    },
+  };
+}
+
+function createSqlite({ eventOwnership = true } = {}) {
+  const sqlite = new DatabaseSync(':memory:');
+  const eventOwnershipColumns = eventOwnership ? 'account_id TEXT, repository_id TEXT,' : '';
+  sqlite.exec([
+    'CREATE TABLE agentsam_workspace_state (',
+    'id TEXT PRIMARY KEY, workspace_id TEXT NOT NULL, repository_id TEXT NOT NULL,',
+    'current_task_id TEXT, state_json TEXT NOT NULL DEFAULT \'{}\',',
+    'state_schema TEXT NOT NULL DEFAULT \'agentsam.blackboard.v1\',',
+    'revision INTEGER NOT NULL DEFAULT 1, locked_by TEXT, lock_expires_at INTEGER,',
+    'checkpoint_sha TEXT, last_agent_action TEXT, updated_at INTEGER NOT NULL);',
+    'CREATE TABLE agentsam_tickets (',
+    'id TEXT PRIMARY KEY, title TEXT NOT NULL, status TEXT NOT NULL, priority TEXT,',
+    'account_id TEXT NOT NULL, repository_id TEXT NOT NULL, goal_schema TEXT,',
+    'goal_spec_json TEXT, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);',
+    'CREATE TABLE agentsam_ticket_events (',
+    'id TEXT PRIMARY KEY, ticket_id TEXT NOT NULL, event_type TEXT NOT NULL, detail TEXT,',
+    'created_at INTEGER NOT NULL, actor_type TEXT, actor_id TEXT, ' + eventOwnershipColumns,
+    'payload_json TEXT NOT NULL DEFAULT \'{}\', workflow_run_id TEXT, execution_step_id TEXT,',
+    'schema_version TEXT NOT NULL DEFAULT \'agentsam.event.v1\');',
+  ].join('\n'));
+  sqlite.prepare(
+    'INSERT INTO agentsam_workspace_state ' +
+    '(id, workspace_id, repository_id, current_task_id, state_json, revision, updated_at) ' +
+    'VALUES (?, ?, ?, NULL, \'{}\', 7, 1)',
+  ).run('bb_sql', scope.workspace_id, scope.repository_id);
+  sqlite.prepare(
+    'INSERT INTO agentsam_tickets ' +
+    '(id, title, status, account_id, repository_id, goal_schema, goal_spec_json, created_at, updated_at) ' +
+    'VALUES (?, ?, \'backlog\', ?, ?, ?, ?, 1, 1)',
+  ).run(
+    'tkt_sql',
+    'Ship portable GOAP',
+    scope.account_id,
+    scope.repository_id,
+    GOAP_SCHEMAS.goal,
+    JSON.stringify({ schema: GOAP_SCHEMAS.goal, desired: [] }),
+  );
+  return sqlite;
+}
+
+
+test('repository_join blackboard ownership rejects cross-account reads on shared stores', async () => {
+  const sqlite = createSqlite();
+  sqlite.exec(
+    'CREATE TABLE code_repositories (id TEXT PRIMARY KEY, account_id TEXT NOT NULL);',
+  );
+  sqlite.prepare(
+    'INSERT INTO code_repositories (id, account_id) VALUES (?, ?)',
+  ).run(scope.repository_id, scope.account_id);
+
+  const ports = createD1SqliteGoapAdapter({
+    db: d1Like(sqlite),
+    blackboardOwnership: 'repository_join',
+  });
+
+  const owned = await ports.blackboardStore.get(scope);
+  assert.equal(owned.repository_id, scope.repository_id);
+
+  const foreign = await ports.blackboardStore.get({
+    ...scope,
+    account_id: 'acct_other',
+  });
+  assert.equal(foreign, null);
+
+  sqlite.close();
+});
+
+test('D1/SQLite adapter atomically guards stale revisions with canonical AgentSam errors', async () => {
+  const sqlite = createSqlite();
+  const ports = createD1SqliteGoapAdapter({ db: d1Like(sqlite) });
+  const service = createGoapControlPlane({ ports, clock: () => 1234 });
+
+  await assert.rejects(
+    service.activateGoal({ scope, goalId: 'tkt_sql', expectedRevision: 6 }),
+    (error) => {
+      assert.equal(error instanceof AgentSamError, true);
+      assert.equal(error.reason, ERROR_REASON.STALE_VERSION);
+      assert.equal(error.envelope.domain, 'tool');
+      assert.equal(error.envelope.tool, 'goap');
+      return true;
+    },
+  );
+
+  assert.equal(sqlite.prepare('SELECT revision FROM agentsam_workspace_state').get().revision, 7);
+  assert.equal(sqlite.prepare('SELECT status FROM agentsam_tickets').get().status, 'backlog');
+  assert.equal(sqlite.prepare('SELECT COUNT(*) AS n FROM agentsam_ticket_events').get().n, 0);
+
+  const result = await service.activateGoal({
+    scope,
+    goalId: 'tkt_sql',
+    expectedRevision: 7,
+    actor: { type: 'test', id: 'sqlite' },
+  });
+
+  assert.equal(result.blackboard.revision, 8);
+  assert.equal(result.blackboard.current_goal_id, 'tkt_sql');
+  assert.equal(result.goal.status, 'active');
+  assert.equal(result.events[0].type, 'goal.activated');
+  assert.match(result.events[0].cursor, /^sqlite:/);
+
+  const eventRow = sqlite.prepare(
+    'SELECT account_id, repository_id, payload_json, schema_version FROM agentsam_ticket_events LIMIT 1',
+  ).get();
+  assert.equal(eventRow.account_id, scope.account_id);
+  assert.equal(eventRow.repository_id, scope.repository_id);
+  assert.equal(eventRow.schema_version, GOAP_SCHEMAS.event);
+  assert.equal(JSON.parse(eventRow.payload_json).blackboard_revision, 8);
+
+  sqlite.close();
+});
+
+test('ticket_join event ownership supports the legacy platform event table', async () => {
+  const sqlite = createSqlite({ eventOwnership: false });
+  const ports = createD1SqliteGoapAdapter({
+    db: d1Like(sqlite),
+    eventOwnership: 'ticket_join',
+    cursorPrefix: 'd1',
+  });
+  const service = createGoapControlPlane({ ports, clock: () => 2000 });
+
+  const result = await service.activateGoal({
+    scope,
+    goalId: 'tkt_sql',
+    expectedRevision: 7,
+  });
+
+  assert.equal(result.blackboard.revision, 8);
+  assert.equal(result.goal.status, 'active');
+  assert.equal(result.events.length, 1);
+  assert.match(result.events[0].cursor, /^d1:/);
+  assert.equal(sqlite.prepare('SELECT COUNT(*) AS n FROM agentsam_ticket_events').get().n, 1);
+
+  sqlite.close();
+});

package/packages/agentsam-goap/test/world.test.mjs

@@ -0,0 +1,79 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { projectGoapWorld, projectPlanActions } from '../src/world.js';
+
+const plan = {
+  id: 'plan_1',
+  title: 'Ship portable loop',
+  status: 'active',
+  tasks_done: 1,
+  tasks_total: 3,
+  tasks: [
+    {
+      id: 'todo_done',
+      title: 'Freeze contract',
+      status: 'complete',
+      priority: 'high',
+      sort_order: 10,
+      metadata: { kind: 'decision', depends_on: [] },
+    },
+    {
+      id: 'todo_active',
+      title: 'Project world',
+      status: 'running',
+      priority: 'critical',
+      sort_order: 20,
+      metadata: { kind: 'implement', depends_on: ['todo_done'], acceptance: [], evidence: [] },
+    },
+    {
+      id: 'todo_next',
+      title: 'Verify loop',
+      status: 'open',
+      priority: 'high',
+      sort_order: 30,
+      metadata: { kind: 'verify', depends_on: ['todo_active'] },
+    },
+  ],
+};
+
+test('projectPlanActions converts TODO dependencies into GOAP preconditions', () => {
+  const actions = projectPlanActions(plan);
+  assert.equal(actions.available.length, 0);
+  assert.equal(actions.blocked.length, 1);
+  assert.equal(actions.blocked[0].id, 'todo_next');
+  assert.equal(actions.blocked[0].blockers[0].id, 'todo_active');
+  assert.deepEqual(actions.blocked[0].spec.preconditions[0], {
+    fact: 'todo.complete',
+    todo_id: 'todo_active',
+    value: true,
+  });
+});
+
+test('projectGoapWorld emits canonical world, blackboard, goal, and action contracts', () => {
+  const world = projectGoapWorld({
+    repository: {
+      repository_id: 'github:example/repo',
+      branch: 'main',
+      revision_sha: 'abc123',
+      dirty: false,
+      merkle_root: 'sha256:merkle',
+    },
+    plan,
+    activeTodo: plan.tasks[1],
+    knowledge: { status: 'current', generation_id: 'gen_1' },
+    evidence: { primitive: 'repository.audit', chars: 900 },
+    revision: 7,
+    updatedAt: 123,
+  });
+
+  assert.equal(world.schema, 'agentsam.goap.world.v1');
+  assert.equal(world.blackboard.schema, 'agentsam.blackboard.v1');
+  assert.equal(world.blackboard.current_goal_id, 'todo_active');
+  assert.equal(world.blackboard.revision, 7);
+  assert.equal(world.blackboard.state.repository.merkle_root, 'sha256:merkle');
+  assert.equal(world.goal.schema, 'agentsam.goal.v1');
+  assert.equal(world.goal.id, 'todo_active');
+  assert.equal(world.goal.status, 'active');
+  assert.equal(world.goal.spec.desired[0].fact, 'todo.complete');
+  assert.equal(world.actions.blocked[0].id, 'todo_next');
+});

package/packages/agentsam-nav/dist/Nav.d.ts

@@ -0,0 +1,43 @@
+import { type HTMLAttributes } from 'react';
+import { NavCollapsible, NavCollapsibleContent, NavCollapsibleTrigger } from './NavCollapsible.js';
+import { NavContent } from './NavContent.js';
+import { NavFooter } from './NavFooter.js';
+import { NavGroup, NavGroupLabel } from './NavGroup.js';
+import { NavHeader } from './NavHeader.js';
+import { NavMenu, NavMenuButton, NavMenuChevron, NavMenuItem, NavMenuSub, NavMenuSubButton } from './NavMenu.js';
+import { NavProvider } from './NavProvider.js';
+import { NavTrigger } from './NavTrigger.js';
+import { NavScope, NavSidenav, NavTopbar, NavTopbarLogo, NavTopbarSpacer, NavProjectContext, NavAccountSwitcher, NavFilesResources, NavPinnedSummary, NavConversationActions, NavShareButton, NavOverflowMenu, NavModeSwitcher } from './Surfaces.js';
+declare function NavRoot({ className, children, ...props }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+export declare const Nav: typeof NavRoot & {
+    Scope: typeof NavScope;
+    Sidenav: typeof NavSidenav;
+    Topbar: typeof NavTopbar;
+    TopbarLogo: typeof NavTopbarLogo;
+    TopbarSpacer: typeof NavTopbarSpacer;
+    ProjectContext: typeof NavProjectContext;
+    AccountSwitcher: typeof NavAccountSwitcher;
+    FilesResources: typeof NavFilesResources;
+    PinnedSummary: typeof NavPinnedSummary;
+    ConversationActions: typeof NavConversationActions;
+    ShareButton: typeof NavShareButton;
+    OverflowMenu: typeof NavOverflowMenu;
+    ModeSwitcher: typeof NavModeSwitcher;
+    Provider: typeof NavProvider;
+    Header: typeof NavHeader;
+    Content: typeof NavContent;
+    Footer: typeof NavFooter;
+    Group: typeof NavGroup;
+    GroupLabel: typeof NavGroupLabel;
+    Menu: typeof NavMenu;
+    MenuItem: typeof NavMenuItem;
+    MenuButton: typeof NavMenuButton;
+    MenuSub: typeof NavMenuSub;
+    MenuSubButton: typeof NavMenuSubButton;
+    MenuChevron: typeof NavMenuChevron;
+    Collapsible: typeof NavCollapsible;
+    CollapsibleTrigger: typeof NavCollapsibleTrigger;
+    CollapsibleContent: typeof NavCollapsibleContent;
+    Trigger: typeof NavTrigger;
+};
+export {};

package/packages/agentsam-nav/dist/NavCollapsible.d.ts

@@ -0,0 +1,10 @@
+import { type ButtonHTMLAttributes, type HTMLAttributes, type ReactElement, type ReactNode } from 'react';
+export declare function NavCollapsible({ children, defaultOpen }: {
+    children: ReactNode;
+    defaultOpen?: boolean;
+}): import("react").JSX.Element;
+export declare function NavCollapsibleTrigger({ render, children, className, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
+    render?: ReactElement;
+    children?: ReactNode;
+}): import("react").JSX.Element;
+export declare function NavCollapsibleContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavContent.d.ts

@@ -0,0 +1,2 @@
+import type { HTMLAttributes } from 'react';
+export declare function NavContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavFooter.d.ts

@@ -0,0 +1,2 @@
+import type { HTMLAttributes } from 'react';
+export declare function NavFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavGroup.d.ts

@@ -0,0 +1,3 @@
+import type { HTMLAttributes } from 'react';
+export declare function NavGroup({ className, ...props }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+export declare function NavGroupLabel({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavHeader.d.ts

@@ -0,0 +1,2 @@
+import type { HTMLAttributes } from 'react';
+export declare function NavHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavMenu.d.ts

@@ -0,0 +1,22 @@
+import type { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
+export declare function NavMenu({ className, ...props }: HTMLAttributes<HTMLUListElement>): import("react").JSX.Element;
+export declare function NavMenuItem({ className, ...props }: HTMLAttributes<HTMLLIElement>): import("react").JSX.Element;
+export type NavMenuButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    icon?: unknown;
+    active?: boolean;
+    itemId?: string;
+    children: ReactNode;
+};
+export declare function NavMenuButton({ icon: Icon, active, itemId, className, children, ...props }: NavMenuButtonProps): import("react").JSX.Element;
+export declare function NavMenuSub({ className, ...props }: HTMLAttributes<HTMLUListElement>): import("react").JSX.Element;
+export type NavMenuSubButtonProps = {
+    href?: string;
+    active?: boolean;
+    className?: string;
+    children?: unknown;
+    onClick?: (event: React.MouseEvent<HTMLAnchorElement>) => void;
+};
+export declare function NavMenuSubButton({ active, className, children, ...props }: NavMenuSubButtonProps): import("react").JSX.Element;
+export declare function NavMenuChevron({ className }: {
+    className?: string;
+}): import("react").JSX.Element;

package/packages/agentsam-nav/dist/NavProvider.d.ts

@@ -0,0 +1,35 @@
+import { type PropsWithChildren } from 'react';
+import type { NavTheme, NavValue, NavTokens } from './contracts.js';
+export type NavContextValue = {
+    data: NavValue;
+    tokens: NavTokens;
+    theme: NavTheme;
+    accentColor: string;
+    menu: string | null;
+    setMenu: (menu: string | null) => void;
+    open: boolean;
+    isMobile: boolean;
+    isPeeking: boolean;
+    peekable: boolean;
+    resizable: boolean;
+    width: number;
+    mobileBreakpoint: number;
+    setOpen: (open: boolean) => void;
+    toggle: () => void;
+    close: () => void;
+    setPeeking: (peeking: boolean) => void;
+    setWidth: (width: number) => void;
+    scrollToItem: (itemId: string) => void;
+};
+export type NavProviderProps = PropsWithChildren<{
+    value?: NavValue;
+    tokens?: NavTokens;
+    theme?: NavTheme;
+    accentColor?: string;
+    defaultOpen?: boolean;
+    mobileBreakpoint?: number;
+    peekable?: boolean;
+    resizable?: boolean;
+}>;
+export declare function NavProvider({ children, value: data, tokens, theme, accentColor, defaultOpen, mobileBreakpoint, peekable, resizable, }: NavProviderProps): import("react").JSX.Element;
+export declare function useNav(): NavContextValue;

package/packages/agentsam-nav/dist/NavTrigger.d.ts

@@ -0,0 +1,2 @@
+import type { ButtonHTMLAttributes } from 'react';
+export declare function NavTrigger({ className, 'aria-label': ariaLabel, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;