@alumbwe/anvil 1.0.20 → 1.0.21

package/vendor/@anvil/common/src/types/session-state.ts

@@ -0,0 +1,149 @@
+import { z } from 'zod/v4'
+
+import { MAX_AGENT_STEPS_DEFAULT } from '../constants/agents'
+
+import type { Message } from './messages/anvil-message'
+import type { ProjectFileContext } from '../util/file'
+
+export const toolCallSchema = z.object({
+  toolName: z.string(),
+  toolCallId: z.string(),
+  input: z.record(z.string(), z.any()),
+})
+export type ToolCall = z.infer<typeof toolCallSchema>
+
+export const subgoalSchema = z.object({
+  objective: z.string().optional(),
+  status: z
+    .enum(['NOT_STARTED', 'IN_PROGRESS', 'COMPLETE', 'ABORTED'])
+    .optional(),
+  plan: z.string().optional(),
+  logs: z.string().array(),
+})
+export type Subgoal = z.infer<typeof subgoalSchema>
+
+export type AgentState = {
+  /**
+   * @deprecated agentId is replaced by runId
+   */
+  agentId: string
+  agentType: AgentTemplateType | null
+  agentContext: Record<string, Subgoal>
+  ancestorRunIds: string[]
+  runId?: string
+  subagents: AgentState[]
+  childRunIds: string[]
+  messageHistory: Message[]
+  stepsRemaining: number
+  creditsUsed: number
+  directCreditsUsed: number
+  output?: Record<string, any>
+  parentId?: string
+  systemPrompt: string
+  toolDefinitions: Record<
+    string,
+    { description: string | undefined; inputSchema: {} }
+  >
+  /**
+   * The accurate token count from the Anthropic API.
+   * This is updated on every agent step via the /api/v1/token-count endpoint.
+   */
+  contextTokenCount: number
+}
+
+export const AgentOutputSchema = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal('structuredOutput'),
+    value: z.record(z.string(), z.any()).or(z.null()),
+  }),
+  z.object({
+    type: z.literal('lastMessage'),
+    value: z.array(z.any()), // Array of assistant and tool messages from the last turn, including tool results
+  }),
+  z.object({
+    type: z.literal('allMessages'),
+    value: z.array(z.any()),
+  }),
+  z.object({
+    type: z.literal('error'),
+    message: z.string(),
+    statusCode: z.number().optional(),
+    error: z.string().optional(),
+    countryCode: z.string().optional(),
+    countryBlockReason: z.string().optional(),
+    ipPrivacySignals: z.array(z.string()).optional(),
+  }),
+])
+export type AgentOutput = z.infer<typeof AgentOutputSchema>
+
+export const AgentTemplateTypeList = [
+  // Base agents
+  'base',
+  'base_free',
+  'base_max',
+  'base_experimental',
+  'claude4_gemini_thinking',
+  'superagent',
+  'base_agent_builder',
+
+  // Ask mode
+  'ask',
+
+  // Planning / Thinking
+  'planner',
+  'dry_run',
+  'thinker',
+
+  // Other agents
+  'file_picker',
+  'file_explorer',
+  'researcher',
+  'reviewer',
+  'agent_builder',
+  'example_programmatic',
+] as const
+type UnderscoreToDash<S extends string> = S extends `${infer L}_${infer R}`
+  ? `${L}-${UnderscoreToDash<R>}` // recurse on the remainder
+  : S
+export const AgentTemplateTypes = Object.fromEntries(
+  AgentTemplateTypeList.map((name) => [name, name.replaceAll('_', '-')]),
+) as { [K in (typeof AgentTemplateTypeList)[number]]: UnderscoreToDash<K> }
+const agentTemplateTypeSchema = z.enum(AgentTemplateTypeList)
+// Allow dynamic agent types by extending the base enum with string
+export type AgentTemplateType =
+  | z.infer<typeof agentTemplateTypeSchema>
+  | (string & {})
+
+export type SessionState = {
+  fileContext: ProjectFileContext
+  mainAgentState: AgentState
+}
+
+export function getInitialAgentState(): AgentState {
+  return {
+    agentId: 'main-agent',
+    agentType: null,
+    agentContext: {},
+    ancestorRunIds: [],
+    runId: undefined,
+    subagents: [],
+    childRunIds: [],
+    messageHistory: [],
+    stepsRemaining: MAX_AGENT_STEPS_DEFAULT,
+    creditsUsed: 0,
+    directCreditsUsed: 0,
+    output: undefined,
+    parentId: undefined,
+    systemPrompt: '',
+    toolDefinitions: {},
+    contextTokenCount: 0,
+  }
+}
+export function getInitialSessionState(
+  fileContext: ProjectFileContext,
+): SessionState {
+  return {
+    mainAgentState: getInitialAgentState(),
+    fileContext,
+  }
+}

package/vendor/@anvil/common/src/types/skill.ts

@@ -0,0 +1,86 @@
+import { z } from 'zod/v4'
+
+import {
+  SKILL_NAME_MAX_LENGTH,
+  SKILL_NAME_REGEX,
+  SKILL_DESCRIPTION_MAX_LENGTH,
+} from '../constants/skills'
+
+/**
+ * Zod schema for skill frontmatter metadata.
+ *
+ * Values are unconstrained on purpose: `metadata` is a free-form bag that
+ * publishers and registries nest their own structures into (skills.sh writes a
+ * `hermes:` block into every skill it serves). Requiring flat strings here
+ * rejected the whole skill over a field nothing reads.
+ */
+export const SkillMetadataSchema = z.record(z.string(), z.unknown())
+
+/**
+ * Zod schema for skill frontmatter (parsed from YAML).
+ */
+export const SkillFrontmatterSchema = z.object({
+  name: z
+    .string()
+    .min(1)
+    .max(SKILL_NAME_MAX_LENGTH)
+    .regex(
+      SKILL_NAME_REGEX,
+      'Name must be lowercase alphanumeric with single hyphen separators',
+    ),
+  // clamped rather than rejected: an over-long description is a reason to show
+  // less of it, never a reason to make the skill unusable
+  description: z
+    .string()
+    .min(1)
+    .transform((d) => d.slice(0, SKILL_DESCRIPTION_MAX_LENGTH)),
+  license: z.string().optional(),
+  'disable-model-invocation': z.boolean().optional(),
+  metadata: SkillMetadataSchema.optional(),
+})
+
+export type SkillFrontmatter = z.infer<typeof SkillFrontmatterSchema>
+
+/**
+ * Full skill definition including content and source path.
+ */
+export const SkillDefinitionSchema = z.object({
+  /** Skill name (must match directory name) */
+  name: z.string(),
+  /** Short description for agent discovery */
+  description: z.string(),
+  /** Optional license */
+  license: z.string().optional(),
+  /** Whether only the user may invoke this skill. */
+  disableModelInvocation: z.boolean().optional(),
+  /** Optional key-value metadata */
+  metadata: SkillMetadataSchema.optional(),
+  /** Full SKILL.md content (including frontmatter) */
+  content: z.string(),
+  /** Source file path */
+  filePath: z.string(),
+})
+
+export type SkillDefinition = z.infer<typeof SkillDefinitionSchema>
+
+export function createSkillDefinition(params: {
+  frontmatter: SkillFrontmatter
+  content: string
+  filePath: string
+}): SkillDefinition {
+  const { frontmatter, content, filePath } = params
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    license: frontmatter.license,
+    disableModelInvocation: frontmatter['disable-model-invocation'],
+    metadata: frontmatter.metadata,
+    content,
+    filePath,
+  }
+}
+
+/**
+ * Collection of skills keyed by skill name.
+ */
+export type SkillsMap = Record<string, SkillDefinition>

package/vendor/@anvil/common/src/types/source.ts

@@ -0,0 +1,11 @@
+/**
+ * Represents a source of data.
+ *
+ * By default, can be a value or a promise.
+ *
+ * In the case that the type is a not function itself, this can also be a function that returns the value or promise.
+ */
+export type Source<T> =
+  | T
+  | Promise<T>
+  | (T extends (...args: unknown[]) => unknown ? never : () => T | Promise<T>)

package/vendor/@anvil/common/src/types/spawn.ts

@@ -0,0 +1,13 @@
+import type { ChildProcess, SpawnOptions } from 'child_process'
+
+/**
+ * Spawn function for running shell commands.
+ *
+ * Compatible with `child_process.spawn` from Node.js.
+ * Returns ChildProcess to support full streaming capabilities (stdin, stdout, stderr).
+ */
+export type AnvilSpawn = (
+  command: string,
+  args?: readonly string[],
+  options?: SpawnOptions,
+) => ChildProcess

package/vendor/@anvil/common/src/types/subscription.ts

@@ -0,0 +1,67 @@
+/**
+ * Core subscription information for an active subscription.
+ */
+export interface SubscriptionInfo {
+  id: string
+  status: string
+  billingPeriodEnd: string
+  cancelAtPeriodEnd: boolean
+  canceledAt: string | null
+  tier: number
+  scheduledTier?: number | null
+}
+
+/**
+ * Rate limit information for subscription usage.
+ */
+export interface SubscriptionRateLimit {
+  limited: boolean
+  reason?: 'block_exhausted' | 'weekly_limit'
+  canStartNewBlock: boolean
+  blockUsed?: number
+  blockLimit?: number
+  blockResetsAt?: string
+  weeklyUsed: number
+  weeklyLimit: number
+  weeklyResetsAt: string
+  weeklyPercentUsed: number
+}
+
+/**
+ * Subscription limits configuration.
+ */
+export interface SubscriptionLimits {
+  creditsPerBlock: number
+  blockDurationHours: number
+  weeklyCreditsLimit: number
+}
+
+/**
+ * Response when user has no active subscription.
+ */
+export interface NoSubscriptionResponse {
+  hasSubscription: false
+  /** Whether user prefers to fallback to a-la-carte credits when subscription limits are reached */
+  fallbackToALaCarte: boolean
+}
+
+/**
+ * Response when user has an active subscription.
+ * All fields are required - no invalid states possible.
+ */
+export interface ActiveSubscriptionResponse {
+  hasSubscription: true
+  displayName: string
+  subscription: SubscriptionInfo
+  rateLimit: SubscriptionRateLimit
+  limits: SubscriptionLimits
+
+  /** Whether user prefers to fallback to a-la-carte credits when subscription limits are reached */
+  fallbackToALaCarte: boolean
+}
+
+/**
+ * Discriminated union for subscription API response.
+ * Use `hasSubscription` to narrow the type.
+ */
+export type SubscriptionResponse = NoSubscriptionResponse | ActiveSubscriptionResponse

package/vendor/@anvil/common/src/types/usage.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod/v4'
+
+import { GrantTypeValues } from './grant'
+
+export const usageDataSchema = z.object({
+  usageThisCycle: z.number(),
+  balance: z.object({
+    totalRemaining: z.number(),
+    totalDebt: z.number(),
+    netBalance: z.number(),
+    breakdown: z.record(z.enum(GrantTypeValues), z.number()),
+  }),
+  nextQuotaReset: z.coerce.date().nullable(),
+})
+
+export type UsageData = z.infer<typeof usageDataSchema>

package/vendor/@anvil/common/src/types/util.ts

@@ -0,0 +1,3 @@
+export type Prettify<T> = {
+  [K in keyof T]: T[K]
+} & {}

package/vendor/@anvil/common/src/util/__tests__/ad-user-agent.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from 'bun:test'
+
+import { getAdUserAgent } from '../ad-user-agent'
+
+describe('getAdUserAgent', () => {
+  test.each([
+    ['darwin', 'Macintosh; Intel Mac OS X'],
+    ['win32', 'Windows NT 10.0'],
+    ['linux', 'X11; Linux x86_64'],
+  ])('returns a browser-like UA for %s', (platform, osFragment) => {
+    const userAgent = getAdUserAgent(platform)
+
+    expect(userAgent).toContain(osFragment)
+    expect(userAgent).toContain('Chrome/')
+    expect(userAgent).not.toStartWith('Bun/')
+  })
+
+  test('falls back to Linux for an unknown platform', () => {
+    expect(getAdUserAgent('other')).toBe(getAdUserAgent('linux'))
+  })
+
+  test('accepts the device OS names used by the ads API', () => {
+    expect(getAdUserAgent('macos')).toBe(getAdUserAgent('darwin'))
+    expect(getAdUserAgent('windows')).toBe(getAdUserAgent('win32'))
+  })
+})

package/vendor/@anvil/common/src/util/__tests__/analytics-dispatcher.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'bun:test'
+
+import { AnalyticsEvent } from '@anvil/common/constants/analytics-events'
+
+import { createAnalyticsDispatcher } from '../analytics-dispatcher'
+
+describe('analytics dispatcher', () => {
+  const level = 'info'
+  const msg = 'hello'
+
+  it('no-ops in dev environment', () => {
+    const dispatcher = createAnalyticsDispatcher({
+      envName: 'dev',
+      bufferWhenNoUser: true,
+    })
+
+    const out = dispatcher.process({
+      data: { eventId: AnalyticsEvent.APP_LAUNCHED, userId: 'u' },
+      level,
+      msg,
+    })
+
+    expect(out).toEqual([])
+  })
+
+  it('emits payload when event and user are present', () => {
+    const dispatcher = createAnalyticsDispatcher({ envName: 'prod' })
+
+    const out = dispatcher.process({
+      data: { eventId: AnalyticsEvent.APP_LAUNCHED, userId: 'u' },
+      level,
+      msg,
+    })
+
+    expect(out).toHaveLength(1)
+    expect(out[0]).toMatchObject({
+      event: AnalyticsEvent.APP_LAUNCHED,
+      userId: 'u',
+      properties: expect.objectContaining({
+        userId: 'u',
+        level,
+        msg,
+      }),
+    })
+  })
+
+  it('buffers when no user and flushes once user appears', () => {
+    const dispatcher = createAnalyticsDispatcher({
+      envName: 'prod',
+      bufferWhenNoUser: true,
+    })
+
+    // Missing user; should buffer
+    const first = dispatcher.process({
+      data: { eventId: AnalyticsEvent.APP_LAUNCHED },
+      level,
+      msg,
+    })
+    expect(first).toEqual([])
+
+    // With user; should flush buffered event first, then this one
+    const second = dispatcher.process({
+      data: {
+        eventId: AnalyticsEvent.AGENT_STEP,
+        userId: 'user-1',
+      },
+      level,
+      msg,
+    })
+
+    expect(second).toHaveLength(2)
+    expect(second[0]).toMatchObject({
+      event: AnalyticsEvent.APP_LAUNCHED,
+      userId: 'user-1',
+    })
+    expect(second[1]).toMatchObject({
+      event: AnalyticsEvent.AGENT_STEP,
+      userId: 'user-1',
+    })
+  })
+
+  it('uses fallbackUserId when rebuilding buffered events', () => {
+    const dispatcher = createAnalyticsDispatcher({
+      envName: 'prod',
+      bufferWhenNoUser: true,
+    })
+
+    dispatcher.process({
+      data: { eventId: AnalyticsEvent.APP_LAUNCHED },
+      level,
+      msg,
+    })
+
+    const out = dispatcher.process({
+      data: {
+        eventId: AnalyticsEvent.AGENT_STEP,
+      },
+      level,
+      msg,
+      fallbackUserId: 'fallback-user',
+    })
+
+    expect(out).toHaveLength(2)
+    expect(out[0].userId).toBe('fallback-user')
+    expect(out[1].userId).toBe('fallback-user')
+  })
+
+  it('ignores unknown events even when buffering is on', () => {
+    const dispatcher = createAnalyticsDispatcher({
+      envName: 'prod',
+      bufferWhenNoUser: true,
+    })
+
+    const out = dispatcher.process({
+      data: { eventId: 'not-real' },
+      level,
+      msg,
+    })
+
+    expect(out).toEqual([])
+  })
+})

package/vendor/@anvil/common/src/util/__tests__/analytics-log.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from 'bun:test'
+
+import { AnalyticsEvent } from '@anvil/common/constants/analytics-events'
+
+import {
+  getAnalyticsEventId,
+  toTrackableAnalyticsPayload,
+  type AnalyticsLogData,
+} from '../analytics-log'
+
+describe('analytics-log helpers', () => {
+  const baseMsg = 'hello'
+  const baseLevel = 'info'
+
+  it('returns null for non-object data', () => {
+    expect(
+      toTrackableAnalyticsPayload({ data: null, level: baseLevel, msg: baseMsg }),
+    ).toBeNull()
+    expect(
+      toTrackableAnalyticsPayload({ data: 'x', level: baseLevel, msg: baseMsg }),
+    ).toBeNull()
+  })
+
+  it('returns null when eventId is missing or unknown', () => {
+    expect(
+      toTrackableAnalyticsPayload({
+        data: {},
+        level: baseLevel,
+        msg: baseMsg,
+      }),
+    ).toBeNull()
+
+    expect(
+      toTrackableAnalyticsPayload({
+        data: { eventId: 'not-real' },
+        level: baseLevel,
+        msg: baseMsg,
+      }),
+    ).toBeNull()
+  })
+
+  it('returns null when user cannot be resolved', () => {
+    expect(
+      toTrackableAnalyticsPayload({
+        data: { eventId: AnalyticsEvent.AGENT_STEP },
+        level: baseLevel,
+        msg: baseMsg,
+      }),
+    ).toBeNull()
+  })
+
+  it('builds payload when event and userId exist', () => {
+    const payload = toTrackableAnalyticsPayload({
+      data: { eventId: AnalyticsEvent.APP_LAUNCHED, userId: 'u1', extra: 123 },
+      level: baseLevel,
+      msg: baseMsg,
+    })!
+
+    expect(payload.event).toBe(AnalyticsEvent.APP_LAUNCHED)
+    expect(payload.userId).toBe('u1')
+    expect(payload.properties).toMatchObject({
+      userId: 'u1',
+      extra: 123,
+      level: baseLevel,
+      msg: baseMsg,
+    })
+  })
+
+  it('falls back to nested and underscored user ids', () => {
+    const fromUser = toTrackableAnalyticsPayload({
+      data: { eventId: AnalyticsEvent.APP_LAUNCHED, user: { id: 'nested' } },
+      level: baseLevel,
+      msg: baseMsg,
+    })
+    expect(fromUser?.userId).toBe('nested')
+
+    const fromUnderscore = toTrackableAnalyticsPayload({
+      data: { eventId: AnalyticsEvent.APP_LAUNCHED, user_id: 'underscored' },
+      level: baseLevel,
+      msg: baseMsg,
+    })
+    expect(fromUnderscore?.userId).toBe('underscored')
+  })
+
+  it('uses fallbackUserId when no user fields exist', () => {
+    const payload = toTrackableAnalyticsPayload({
+      data: { eventId: AnalyticsEvent.APP_LAUNCHED },
+      level: baseLevel,
+      msg: baseMsg,
+      fallbackUserId: 'fallback',
+    })!
+
+    expect(payload.userId).toBe('fallback')
+  })
+
+  it('getAnalyticsEventId returns only known events', () => {
+    const data: AnalyticsLogData = { eventId: AnalyticsEvent.APP_LAUNCHED }
+    expect(getAnalyticsEventId(data)).toBe(AnalyticsEvent.APP_LAUNCHED)
+    expect(getAnalyticsEventId({ eventId: 'nope' })).toBeNull()
+    expect(getAnalyticsEventId(null)).toBeNull()
+  })
+})