@alumbwe/anvil 1.0.42 → 1.0.50

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

@@ -1,298 +0,0 @@
-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

@@ -1,116 +0,0 @@
-/**
- * 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

@@ -1,167 +0,0 @@
-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')
-  })
-})