@alumbwe/anvil 1.0.20 → 1.0.22

package/vendor/@anvil/common/src/__tests__/project-file-tree.test.ts

@@ -0,0 +1,298 @@
+import os from 'os'
+import path from 'path'
+
+import { describe, expect, it } from 'bun:test'
+
+import {
+  flattenTree,
+  getAllPathsWithDirectories,
+  getProjectFileTree,
+  isFileIgnored,
+} from '../project-file-tree'
+import { createMockFs } from '../testing/mocks/filesystem'
+
+/**
+ * Builds a mock fs from relative file paths under `root`, inferring
+ * intermediate directories.
+ */
+function createFsWithFiles(root: string, files: string[]) {
+  const fileRecords: Record<string, string> = {}
+  const dirChildren: Record<string, Set<string>> = { [root]: new Set() }
+  for (const file of files) {
+    fileRecords[path.join(root, file)] = ''
+    let child = path.join(root, file)
+    let dir = path.dirname(child)
+    while (true) {
+      ;(dirChildren[dir] ??= new Set()).add(path.basename(child))
+      if (dir === root) break
+      child = dir
+      dir = path.dirname(dir)
+    }
+  }
+  return createMockFs({
+    files: fileRecords,
+    directories: Object.fromEntries(
+      Object.entries(dirChildren).map(([dir, names]) => [dir, [...names]]),
+    ),
+  })
+}
+
+describe('getProjectFileTree', () => {
+  it('scans the home directory shallowly instead of returning nothing', async () => {
+    const home = os.homedir()
+    const fs = createFsWithFiles(home, [
+      'top-level.txt',
+      'proj/README.md',
+      'proj/docs/guide.md',
+      'proj/docs/deep/too-deep.md',
+      '.hidden/secret.txt',
+    ])
+
+    const tree = await getProjectFileTree({ projectRoot: home, fs })
+    const paths = getAllPathsWithDirectories(tree).map((p) => p.path)
+
+    // Files up to 3 levels deep are included
+    expect(paths).toContain('top-level.txt')
+    expect(paths).toContain(path.join('proj', 'README.md'))
+    expect(paths).toContain(path.join('proj', 'docs', 'guide.md'))
+    // The depth-3 directory shows up as a node, but its contents do not
+    expect(paths).toContain(path.join('proj', 'docs', 'deep'))
+    expect(paths).not.toContain(
+      path.join('proj', 'docs', 'deep', 'too-deep.md'),
+    )
+    // Dotfiles are still excluded
+    expect(paths.some((p) => p.includes('.hidden'))).toBe(false)
+  })
+
+  it('scans regular project roots without a depth limit', async () => {
+    const root = '/repo'
+    const fs = createFsWithFiles(root, ['a/b/c/d/e.txt'])
+
+    const tree = await getProjectFileTree({ projectRoot: root, fs })
+    const paths = getAllPathsWithDirectories(tree).map((p) => p.path)
+
+    expect(paths).toContain(path.join('a', 'b', 'c', 'd', 'e.txt'))
+  })
+
+  it('records file paths with forward slashes', async () => {
+    // `ignore` and the glob patterns the model writes are both POSIX-only, and
+    // `ignore` answers false for a backslash path rather than throwing. Storing
+    // anything but forward slashes here makes nested rules stop pruning on
+    // Windows, which is how build output ends up eating the maxFiles budget.
+    const root = '/repo'
+    const fs = createFsWithFiles(root, ['app/src/main/Inventory.kt'])
+
+    const tree = await getProjectFileTree({ projectRoot: root, fs })
+
+    const filePaths = flattenTree(tree).map((node) => node.filePath)
+    expect(filePaths).toEqual(['app/src/main/Inventory.kt'])
+  })
+
+  it('prunes directories ignored by a rule in a nested .gitignore', async () => {
+    const root = '/repo'
+    const fs = createFsWithFiles(root, [
+      'app/.gitignore',
+      'app/build/output.class',
+      'app/src/Inventory.kt',
+    ])
+    ;(fs.readFile as any).mockImplementation(async (filePath: string) =>
+      String(filePath).endsWith('.gitignore') ? 'build/\n' : '',
+    )
+
+    const tree = await getProjectFileTree({ projectRoot: root, fs })
+
+    const filePaths = flattenTree(tree).map((node) => node.filePath)
+    expect(filePaths).toContain('app/src/Inventory.kt')
+    expect(filePaths).not.toContain('app/build/output.class')
+  })
+
+  it('keeps nested rules scoped to their own directory even when its name contains glob syntax', async () => {
+    const root = '/repo'
+    const fs = createFsWithFiles(root, [
+      '[4K- HDR]/.gitignore',
+      '[4K- HDR]/x/logs',
+      '[4K- HDR]/keep.ts',
+      'a/x/logs',
+    ])
+    ;(fs.readFile as any).mockImplementation(async (filePath: string) =>
+      String(filePath).endsWith('.gitignore') ? 'logs\n' : '',
+    )
+
+    const filePaths = flattenTree(
+      await getProjectFileTree({ projectRoot: root, fs }),
+    ).map((node) => node.filePath)
+
+    expect(filePaths).toContain('[4K- HDR]/keep.ts')
+    expect(filePaths).not.toContain('[4K- HDR]/x/logs')
+    expect(filePaths).toContain('a/x/logs')
+  })
+
+  it('keeps anchored rules in a nested .gitignore anchored to that directory', async () => {
+    const root = '/repo'
+    const fs = createFsWithFiles(root, [
+      'pkg/.gitignore',
+      'pkg/dist/a.js',
+      'pkg/sub/dist/b.js',
+    ])
+    ;(fs.readFile as any).mockImplementation(async (filePath: string) =>
+      String(filePath) === path.join(root, 'pkg', '.gitignore')
+        ? '/dist\n'
+        : '',
+    )
+
+    const filePaths = flattenTree(
+      await getProjectFileTree({ projectRoot: root, fs }),
+    ).map((node) => node.filePath)
+
+    expect(filePaths).not.toContain('pkg/dist/a.js')
+    expect(filePaths).toContain('pkg/sub/dist/b.js')
+  })
+
+  it('does not let a nested negation re-include a file under a directory excluded by an ancestor', async () => {
+    const root = '/repo'
+    const fs = createFsWithFiles(root, [
+      '.gitignore',
+      'pkg/.gitignore',
+      'pkg/dist/index.css',
+      'pkg/src/a.ts',
+    ])
+    ;(fs.readFile as any).mockImplementation(async (filePath: string) => {
+      const p = String(filePath)
+      if (p === path.join(root, '.gitignore')) return 'dist/\n'
+      if (p === path.join(root, 'pkg', '.gitignore'))
+        return '!dist/index.css\n'
+      return ''
+    })
+
+    const filePaths = flattenTree(
+      await getProjectFileTree({ projectRoot: root, fs }),
+    ).map((node) => node.filePath)
+
+    expect(filePaths).toContain('pkg/src/a.ts')
+    expect(filePaths).not.toContain('pkg/dist/index.css')
+  })
+
+  it('skips ignore rules that cannot be compiled without dropping the rest of the file', async () => {
+    const root = '/repo'
+    const fs = createFsWithFiles(root, [
+      '.gitignore',
+      'build/out.js',
+      'src/main.ts',
+    ])
+    ;(fs.readFile as any).mockImplementation(async (filePath: string) =>
+      String(filePath).endsWith('.gitignore') ? '[~-a]\nbuild/\n' : '',
+    )
+
+    const filePaths = flattenTree(
+      await getProjectFileTree({ projectRoot: root, fs }),
+    ).map((node) => node.filePath)
+
+    expect(filePaths).toContain('src/main.ts')
+    expect(filePaths).not.toContain('build/out.js')
+  })
+})
+
+describe('isFileIgnored', () => {
+  it('can exempt env templates from defaults while preserving project rules', async () => {
+    const root = '/repo'
+    const withoutProjectRule = createFsWithFiles(root, ['.env.example'])
+
+    expect(
+      await isFileIgnored({
+        filePath: '.env.example',
+        projectRoot: root,
+        fs: withoutProjectRule,
+      }),
+    ).toBe(true)
+    expect(
+      await isFileIgnored({
+        filePath: '.env.example',
+        projectRoot: root,
+        fs: withoutProjectRule,
+        allowEnvTemplate: true,
+      }),
+    ).toBe(false)
+    expect(
+      await isFileIgnored({
+        filePath: '.env.local',
+        projectRoot: root,
+        fs: withoutProjectRule,
+        allowEnvTemplate: true,
+      }),
+    ).toBe(true)
+
+    const withProjectRule = createFsWithFiles(root, [
+      '.gitignore',
+      '.env.example',
+    ])
+    ;(withProjectRule.readFile as any).mockImplementation(
+      async (filePath: string) =>
+        String(filePath) === path.join(root, '.gitignore')
+          ? '.env.example\n'
+          : '',
+    )
+
+    expect(
+      await isFileIgnored({
+        filePath: '.env.example',
+        projectRoot: root,
+        fs: withProjectRule,
+        allowEnvTemplate: true,
+      }),
+    ).toBe(true)
+  })
+
+  it('fails closed when an env template project rule is unreadable', async () => {
+    const root = '/repo'
+    const fs = createFsWithFiles(root, ['.gitignore', '.env.example'])
+    ;(fs.readFile as any).mockImplementation(async (filePath: string) => {
+      if (String(filePath) === path.join(root, '.gitignore')) {
+        const error = new Error('permission denied') as Error & {
+          code: string
+        }
+        error.code = 'EACCES'
+        throw error
+      }
+      return 'API_KEY=example'
+    })
+
+    expect(
+      await isFileIgnored({
+        filePath: '.env.example',
+        projectRoot: root,
+        fs,
+        allowEnvTemplate: true,
+      }),
+    ).toBe(true)
+  })
+
+  it('reads ignore rules at the filesystem root without looping', async () => {
+    const root = path.parse(process.cwd()).root
+    const fs = createMockFs({
+      files: { [path.join(root, '.gitignore')]: 'readme.txt\n' },
+    })
+
+    expect(
+      await isFileIgnored({ filePath: 'readme.txt', projectRoot: root, fs }),
+    ).toBe(true)
+  })
+
+  it('keeps default-ignored directories excluded despite a root negation', async () => {
+    const root = '/repo'
+    const fs = createFsWithFiles(root, [
+      '.gitignore',
+      'node_modules/pkg/README.md',
+    ])
+    ;(fs.readFile as any).mockImplementation(async (filePath: string) =>
+      String(filePath) === path.join(root, '.gitignore') ? '!*.md\n' : '',
+    )
+
+    expect(
+      await isFileIgnored({
+        filePath: 'node_modules/pkg/README.md',
+        projectRoot: root,
+        fs,
+      }),
+    ).toBe(true)
+  })
+})

package/vendor/@anvil/common/src/__tests__/provisioned-model-tiers.test.ts

@@ -0,0 +1,116 @@
+/**
+ * The provisioned `-max` tiers.
+ *
+ * These are granted per account rather than picked, so the invariant is the
+ * opposite of a normal model's: every catalog must NOT contain them. A client
+ * that rendered one would offer a row most accounts cannot run, and the
+ * request would fail at admission rather than at the picker — the confusing
+ * shape a hidden tier always takes when it leaks into a selectable list.
+ *
+ * Each tier is pinned to exactly one root, like every other free-mode model,
+ * and each root is pinned to exactly that tier: a root that also accepted the
+ * base model would be a second, unmetered door onto it — which is what the
+ * retired `base2-free-glm-crof` route turned out to be.
+ */
+import { describe, expect, test } from 'bun:test'
+
+import {
+  FREE_MODE_AGENT_MODELS,
+  ANVIL_CLI_BASE3_AGENT_ID_BY_MODEL,
+  ANVIL_ROOT_AGENT_IDS,
+  ANVIL_WEB_BASE3_AGENT_ID_BY_MODEL,
+  isFreeModeAllowedAgentModel,
+} from '../constants/free-agents'
+import {
+  ANVIL_DEEPSEEK_V4_FLASH_MAX_MODEL_ID,
+  ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+  ANVIL_DEEPSEEK_V4_PRO_MAX_MODEL_ID,
+  ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+  ANVIL_GPT_5_6_LUNA_MAX_MODEL_ID,
+  ANVIL_GPT_5_6_LUNA_MODEL_ID,
+  ANVIL_MODELS,
+  ANVIL_PROVISIONED_MODELS,
+  ANVIL_WEB_ALL_MODELS,
+  ANVIL_WEB_MODELS,
+  ANVIL_WEB_PREMIUM_MODEL_IDS,
+  ANVIL_WEB_STANDARD_MODEL_IDS,
+  SUPPORTED_ANVIL_MODELS,
+  resolveSupportedAnvilModel,
+} from '../constants/anvil-models'
+
+/** tier -> the root that runs it, and the base model it extends. */
+const TIERS: Array<{ id: string; root: string; base: string }> = [
+  {
+    id: ANVIL_DEEPSEEK_V4_PRO_MAX_MODEL_ID,
+    root: 'base2-free-deepseek-pro-max',
+    base: ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+  },
+  {
+    id: ANVIL_DEEPSEEK_V4_FLASH_MAX_MODEL_ID,
+    root: 'base2-free-deepseek-flash-max',
+    base: ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+  },
+  {
+    id: ANVIL_GPT_5_6_LUNA_MAX_MODEL_ID,
+    root: 'base2-free-luna-max',
+    base: ANVIL_GPT_5_6_LUNA_MODEL_ID,
+  },
+]
+
+describe('provisioned tiers are never offered from a catalog', () => {
+  test('the tier list is not empty', () => {
+    // Floor: an empty list makes every case below vacuous.
+    expect(ANVIL_PROVISIONED_MODELS.length).toBe(TIERS.length)
+  })
+
+  const catalogs: Array<[string, readonly string[]]> = [
+    ['SUPPORTED_ANVIL_MODELS', SUPPORTED_ANVIL_MODELS.map((m) => m.id)],
+    ['ANVIL_MODELS', ANVIL_MODELS.map((m) => m.id)],
+    ['ANVIL_WEB_MODELS', ANVIL_WEB_MODELS.map((m) => m.id)],
+    ['ANVIL_WEB_ALL_MODELS', ANVIL_WEB_ALL_MODELS.map((m) => m.id)],
+    ['ANVIL_WEB_PREMIUM_MODEL_IDS', [...ANVIL_WEB_PREMIUM_MODEL_IDS]],
+    ['ANVIL_WEB_STANDARD_MODEL_IDS', [...ANVIL_WEB_STANDARD_MODEL_IDS]],
+  ]
+
+  test.each(catalogs)('%s omits every provisioned tier', (_name, ids) => {
+    for (const tier of TIERS) expect(ids).not.toContain(tier.id)
+  })
+
+  test('a saved preference for a tier falls back to a pickable model', () => {
+    for (const tier of TIERS) {
+      expect(resolveSupportedAnvilModel(tier.id)).not.toBe(tier.id)
+    }
+  })
+
+  test('no base3 root map resolves a provisioned tier', () => {
+    for (const tier of TIERS) {
+      expect(ANVIL_WEB_BASE3_AGENT_ID_BY_MODEL[tier.id]).toBeUndefined()
+      expect(ANVIL_CLI_BASE3_AGENT_ID_BY_MODEL[tier.id]).toBeUndefined()
+    }
+  })
+})
+
+describe('each tier is pinned to exactly one root', () => {
+  test.each(TIERS)('$id runs on $root and nothing else', (tier) => {
+    expect(FREE_MODE_AGENT_MODELS[tier.root]?.has(tier.id)).toBe(true)
+    expect(isFreeModeAllowedAgentModel(tier.root, tier.id)).toBe(true)
+  })
+
+  test.each(TIERS)('$root cannot run the base model $base', (tier) => {
+    // A second, unmetered door onto the base model otherwise.
+    expect(isFreeModeAllowedAgentModel(tier.root, tier.base)).toBe(false)
+  })
+
+  test.each(TIERS)('$root is a registered root agent', (tier) => {
+    // A root absent from this list is treated as a subagent, so a top-level
+    // request on it fails the hierarchy check instead of running.
+    expect(ANVIL_ROOT_AGENT_IDS).toContain(tier.root)
+  })
+
+  test.each(TIERS)('the base model does not run on $root', (tier) => {
+    const rootForBase = Object.entries(FREE_MODE_AGENT_MODELS).filter(
+      ([agentId, models]) => models.has(tier.base) && agentId === tier.root,
+    )
+    expect(rootForBase).toEqual([])
+  })
+})

package/vendor/@anvil/common/src/__tests__/reasoning-effort.test.ts

@@ -0,0 +1,167 @@
+import { describe, expect, test } from 'bun:test'
+
+import type { AnvilModelOption } from '../constants/anvil-models'
+import {
+  clampReasoningEffort,
+  reasoningEffortRank,
+  REASONING_EFFORTS,
+  type ReasoningEffort,
+} from '../constants/reasoning-effort'
+import {
+  EFFORTS_THROUGH_HIGH,
+  EFFORTS_THROUGH_MAX,
+  EFFORTS_THROUGH_XHIGH,
+  ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+  ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+  ANVIL_FABLE_5_MODEL_ID,
+  ANVIL_GLM_V52_MODEL_ID,
+  ANVIL_GPT_5_6_LUNA_MODEL_ID,
+  ANVIL_KIMI_K3_ECO_MODEL_ID,
+  ANVIL_MIMO_V25_MODEL_ID,
+  ANVIL_MINIMAX_M3_MODEL_ID,
+  ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID,
+  ANVIL_WEB_ALL_MODELS,
+  getAnvilModelDefaultEffort,
+  getAnvilModelEfforts,
+  getAnvilModelReasoningEffort,
+  resolveAnvilReasoningEffort,
+  SUPPORTED_ANVIL_MODELS,
+} from '../constants/anvil-models'
+
+describe('the shared effort ladder', () => {
+  test('is ordered ascending, because the clamp does index arithmetic on it', () => {
+    // clampReasoningEffort answers "the most this model allows, but no more
+    // than was asked". That is only meaningful if position implies magnitude,
+    // so a reorder here would silently invert every clamp in the product.
+    expect(REASONING_EFFORTS).toEqual([
+      'minimal',
+      'low',
+      'medium',
+      'high',
+      'xhigh',
+      'max',
+      'ultra',
+    ])
+    expect(reasoningEffortRank('low')).toBeLessThan(reasoningEffortRank('high'))
+    expect(reasoningEffortRank('high')).toBeLessThan(
+      reasoningEffortRank('xhigh'),
+    )
+  })
+
+  test('clamps DOWN to the ceiling rather than falling back to a default', () => {
+    // The distinction that matters on a reroute: a user on xhigh whose request
+    // lands on a model topping out at high should get high — the closest thing
+    // to what they chose — not that model's default, which could be lower.
+    expect(clampReasoningEffort('xhigh', EFFORTS_THROUGH_HIGH, 'low')).toBe(
+      'high',
+    )
+    expect(clampReasoningEffort('ultra', EFFORTS_THROUGH_XHIGH, 'low')).toBe(
+      'xhigh',
+    )
+    // Exactly on a rung is that rung.
+    expect(clampReasoningEffort('medium', EFFORTS_THROUGH_HIGH, 'high')).toBe(
+      'medium',
+    )
+    // Nothing recognizable asked for: the caller's fallback, not a guess.
+    expect(clampReasoningEffort(undefined, EFFORTS_THROUGH_HIGH, 'high')).toBe(
+      'high',
+    )
+    expect(clampReasoningEffort('bogus', EFFORTS_THROUGH_HIGH, 'high')).toBe(
+      'high',
+    )
+    // Below everything on offer: the least of them, never nothing.
+    expect(clampReasoningEffort('low', ['high', 'xhigh'], 'xhigh')).toBe('high')
+  })
+})
+
+// `as const satisfies AnvilModelOption` gives each row a narrow literal
+// type, so the union has no `efforts` property at all unless every member
+// declares one. Widening once here keeps the invariants readable.
+const ALL_ROWS: readonly AnvilModelOption[] = [
+  ...SUPPORTED_ANVIL_MODELS,
+  ...ANVIL_WEB_ALL_MODELS,
+]
+
+describe('per-model effort ladders', () => {
+  test('every ladder contains its default', () => {
+    for (const model of ALL_ROWS) {
+      if (!model.efforts?.length) continue
+      const dflt = getAnvilModelDefaultEffort(model.id)!
+      expect({
+        id: model.id,
+        containsDefault: model.efforts.includes(dflt),
+      }).toEqual({ id: model.id, containsDefault: true })
+    }
+  })
+
+  test('every ladder rung is a rung of the shared vocabulary', () => {
+    for (const model of ALL_ROWS) {
+      for (const effort of model.efforts ?? []) {
+        expect(REASONING_EFFORTS).toContain(effort)
+      }
+    }
+  })
+
+  test('Muse Spark and Luna expose their complete native ladders', () => {
+    expect(getAnvilModelEfforts(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID)).toEqual(
+      EFFORTS_THROUGH_XHIGH,
+    )
+    expect(getAnvilModelEfforts(ANVIL_GPT_5_6_LUNA_MODEL_ID)).toEqual(
+      EFFORTS_THROUGH_MAX,
+    )
+    expect(
+      resolveAnvilReasoningEffort(ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID, undefined),
+    ).toBe('xhigh')
+    expect(
+      resolveAnvilReasoningEffort(ANVIL_GPT_5_6_LUNA_MODEL_ID, undefined),
+    ).toBe('high')
+  })
+
+  test('Claude Fable 5 exposes every enabled effort', () => {
+    expect(getAnvilModelEfforts(ANVIL_FABLE_5_MODEL_ID)).toEqual(
+      EFFORTS_THROUGH_MAX,
+    )
+    expect(getAnvilModelDefaultEffort(ANVIL_FABLE_5_MODEL_ID)).toBe(
+      'high',
+    )
+  })
+
+  test('DeepSeek exposes the three native V4 efforts on both models', () => {
+    // One ladder since the Pro 08/13 GA build: DeepSeek documents the same
+    // requested→actual mapping for flash and pro, and low is a real template on
+    // both. Medium is not, on either, so it must not appear as a rung.
+    for (const id of [
+      ANVIL_DEEPSEEK_V4_PRO_MODEL_ID,
+      ANVIL_DEEPSEEK_V4_FLASH_MODEL_ID,
+    ]) {
+      expect(getAnvilModelEfforts(id)).toEqual(['low', 'high', 'max'])
+      expect(resolveAnvilReasoningEffort(id, undefined)).toBe('high')
+      expect(getAnvilModelReasoningEffort(id)).toBe('high')
+      expect(resolveAnvilReasoningEffort(id, 'medium')).toBe('high')
+      expect(resolveAnvilReasoningEffort(id, 'max')).toBe('max')
+      expect(resolveAnvilReasoningEffort(id, 'low')).toBe('low')
+    }
+  })
+
+  test('binary, adaptive, and ignored controls do not masquerade as ladders', () => {
+    for (const id of [
+      ANVIL_MINIMAX_M3_MODEL_ID,
+      ANVIL_MIMO_V25_MODEL_ID,
+      ANVIL_GLM_V52_MODEL_ID,
+      ANVIL_KIMI_K3_ECO_MODEL_ID,
+    ]) {
+      expect(getAnvilModelEfforts(id)).toBeNull()
+      expect(resolveAnvilReasoningEffort(id, 'low')).toBeNull()
+    }
+    expect(resolveAnvilReasoningEffort('some/unknown-model', 'high')).toBeNull()
+  })
+
+  test('a dated provider snapshot resolves like the undated id', () => {
+    expect(
+      resolveAnvilReasoningEffort(
+        `${ANVIL_MUSE_SPARK_12_CONTRIBUTOR_MODEL_ID}-20260901`,
+        'low',
+      ),
+    ).toBe('low')
+  })
+})