@ontrails/trails 1.0.0-beta.14 → 1.0.0-beta.16

package/src/__tests__/load-app.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { resolve } from 'node:path';
-
-import { loadApp } from '../trails/load-app.js';
-
-const writeLoadAppFixture = (cwd: string, name: string): void => {
-  writeFileSync(
-    resolve(cwd, 'src/app.ts'),
-    `export const app = {
-  name: '${name}',
-  trails: new Map(),
-  signals: new Map(),
-  provisions: new Map()
-};`
-  );
-};
-
-const assertLoadAppCaching = async (cwd: string): Promise<void> => {
-  writeLoadAppFixture(cwd, 'first');
-
-  const first = await loadApp('./src/app.ts', cwd);
-
-  writeLoadAppFixture(cwd, 'second');
-
-  const cached = await loadApp('./src/app.ts', cwd);
-  const fresh = await loadApp('./src/app.ts', cwd, { fresh: true });
-
-  expect(first.name).toBe('first');
-  expect(cached.name).toBe('first');
-  expect(fresh.name).toBe('second');
-};
-
-describe('loadApp', () => {
-  test('resolves relative module paths from cwd', async () => {
-    // import.meta.dir is src/__tests__/, go up two to get apps/trails/
-    const cwd = resolve(import.meta.dir, '../..');
-    const app = await loadApp('./src/app.ts', cwd);
-
-    expect(app.name).toBe('trails');
-    expect(app.get('survey')).toBeDefined();
-  });
-
-  test('can bypass module caching with fresh loading', async () => {
-    const cwd = resolve(
-      tmpdir(),
-      `trails-load-app-${Date.now()}-${Math.random().toString(36).slice(2)}`
-    );
-
-    try {
-      mkdirSync(resolve(cwd, 'src'), { recursive: true });
-      await assertLoadAppCaching(cwd);
-    } finally {
-      rmSync(cwd, { force: true, recursive: true });
-    }
-  });
-});

package/src/__tests__/survey.test.ts

@@ -1,301 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from 'node:fs';
-import { join, resolve } from 'node:path';
-
-import { Result, provision, topo, trail } from '@ontrails/core';
-import {
-  generateTrailheadMap,
-  hashTrailheadMap,
-  diffTrailheadMaps,
-} from '@ontrails/schema';
-import type { TrailheadMap } from '@ontrails/schema';
-import { z } from 'zod';
-
-import {
-  generateBriefReport,
-  generateSurveyList,
-  generateTrailDetail,
-  surveyTrail,
-} from '../trails/survey.js';
-import type {
-  BriefReport,
-  SurveyListReport,
-  TrailDetailReport,
-} from '../trails/survey.js';
-
-// ---------------------------------------------------------------------------
-// Test fixtures
-// ---------------------------------------------------------------------------
-
-const helloTrail = trail('hello', {
-  blaze: (input) => {
-    const name = input.name ?? 'world';
-    return Result.ok({ message: `Hello, ${name}!` });
-  },
-  description: 'Say hello',
-  detours: {
-    NotFoundError: ['search'],
-  },
-  examples: [
-    {
-      expected: { message: 'Hello, world!' },
-      input: {},
-      name: 'Default greeting',
-    },
-  ],
-  input: z.object({ name: z.string().optional() }),
-  intent: 'read',
-  output: z.object({ message: z.string() }),
-  provisions: [
-    provision('db.main', {
-      create: () => Result.ok({ source: 'factory' }),
-    }),
-  ],
-});
-
-const byeTrail = trail('bye', {
-  blaze: (input) => Result.ok({ message: `Goodbye, ${input.name}!` }),
-  description: 'Say goodbye',
-  input: z.object({ name: z.string() }),
-  output: z.object({ message: z.string() }),
-});
-
-const [dbProvision] = helloTrail.provisions;
-if (!dbProvision) {
-  throw new Error('Expected helloTrail to declare db.main');
-}
-
-const app = topo('test-app', {
-  bye: byeTrail,
-  dbProvision,
-  hello: helloTrail,
-});
-
-const expectOk = <T>(result: Result<T, Error>): T => {
-  if (result.isErr()) {
-    throw result.error;
-  }
-  return result.value;
-};
-
-const writeSurveyAppFixture = (dir: string): void => {
-  mkdirSync(join(dir, 'src'), { recursive: true });
-  writeFileSync(
-    join(dir, 'src', 'app.ts'),
-    `import { Result, provision, topo, trail } from '@ontrails/core';
-import { z } from 'zod';
-
-const hello = trail('hello', {
-  blaze: async (input) => Result.ok({ message: \`Hello, \${input.name ?? 'world'}!\` }),
-  input: z.object({ name: z.string().optional() }),
-  intent: 'read',
-  output: z.object({ message: z.string() }),
-  provisions: [
-    provision('db.main', {
-      create: () => Result.ok({ source: 'factory' }),
-    }),
-  ],
-});
-
-const [dbMain] = hello.provisions;
-if (!dbMain) {
-  throw new Error('expected hello to declare db.main');
-}
-
-export const app = topo('survey-fixture', { dbMain, hello });
-`
-  );
-};
-
-const repoTempDir = (): string =>
-  join(
-    resolve(import.meta.dir, '../..'),
-    '.tmp-tests',
-    `trails-survey-${Date.now()}-${Math.random().toString(36).slice(2)}`
-  );
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('trails survey', () => {
-  test('generateTrailheadMap includes all trails', () => {
-    const trailheadMap = generateTrailheadMap(app);
-    expect(trailheadMap.entries.length).toBe(3);
-    const ids = trailheadMap.entries.map((e) => e.id);
-    expect(ids).toContain('hello');
-    expect(ids).toContain('bye');
-    expect(ids).toContain('db.main');
-  });
-
-  test('trailhead map entries have expected fields', () => {
-    const trailheadMap = generateTrailheadMap(app);
-    const hello = trailheadMap.entries.find((e) => e.id === 'hello');
-    expect(hello).toBeDefined();
-    expect(hello?.cli?.path).toEqual(['hello']);
-    expect(hello?.kind).toBe('trail');
-    expect(hello?.intent).toBe('read');
-    expect(hello?.exampleCount).toBe(1);
-    expect(hello?.provisions).toEqual(['db.main']);
-  });
-
-  test('JSON output is valid JSON', () => {
-    const trailheadMap = generateTrailheadMap(app);
-    const json = JSON.stringify(trailheadMap, null, 2);
-    const parsed = JSON.parse(json) as TrailheadMap;
-    expect(parsed.version).toBe('1.0');
-    expect(parsed.entries.length).toBe(3);
-  });
-
-  test('hashTrailheadMap produces stable hash', () => {
-    const trailheadMap = generateTrailheadMap(app);
-    const hash1 = hashTrailheadMap(trailheadMap);
-    const hash2 = hashTrailheadMap(trailheadMap);
-    expect(hash1).toBe(hash2);
-    // SHA-256 hex
-    expect(hash1.length).toBe(64);
-  });
-
-  test('diffTrailheadMaps detects added trails', () => {
-    const prev = generateTrailheadMap(topo('test', { hello: helloTrail }));
-    const curr = generateTrailheadMap(app);
-    const diff = diffTrailheadMaps(prev, curr);
-
-    expect(diff.info.length).toBeGreaterThan(0);
-    const addedBye = diff.info.find((e) => e.id === 'bye');
-    expect(addedBye).toBeDefined();
-    expect(addedBye?.change).toBe('added');
-  });
-
-  test('diffTrailheadMaps detects removed trails', () => {
-    const prev = generateTrailheadMap(app);
-    const curr = generateTrailheadMap(topo('test', { hello: helloTrail }));
-    const diff = diffTrailheadMaps(prev, curr);
-
-    expect(diff.hasBreaking).toBe(true);
-    const removedBye = diff.breaking.find((e) => e.id === 'bye');
-    expect(removedBye).toBeDefined();
-    expect(removedBye?.change).toBe('removed');
-  });
-
-  test('diffTrailheadMaps returns empty for identical maps', () => {
-    const trailheadMap = generateTrailheadMap(app);
-    const diff = diffTrailheadMaps(trailheadMap, trailheadMap);
-    expect(diff.entries.length).toBe(0);
-    expect(diff.hasBreaking).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Brief mode (formerly scout)
-// ---------------------------------------------------------------------------
-
-describe('trails survey --brief', () => {
-  test('produces a valid capability report', () => {
-    const report = generateBriefReport(app);
-    expect(report.name).toBe('test-app');
-    expect(report.contractVersion).toBe('2026-03');
-  });
-
-  test('report includes correct trail count', () => {
-    const report = generateBriefReport(app);
-    expect(report.trails).toBe(2);
-    expect(report.signals).toBe(0);
-    expect(report.provisions).toBe(1);
-  });
-
-  test('detects features in use', () => {
-    const report = generateBriefReport(app);
-    expect(report.features.outputSchemas).toBe(true);
-    expect(report.features.examples).toBe(true);
-    expect(report.features.detours).toBe(true);
-    expect(report.features.signals).toBe(false);
-    expect(report.features.provisions).toBe(true);
-  });
-
-  test('JSON output is valid', () => {
-    const report = generateBriefReport(app);
-    const json = JSON.stringify(report, null, 2);
-    const parsed = JSON.parse(json) as BriefReport;
-    expect(parsed.name).toBe('test-app');
-    expect(parsed.trails).toBe(2);
-    expect(parsed.provisions).toBe(1);
-  });
-
-  test('empty app reports zero features', () => {
-    const emptyApp = topo('empty', {});
-    const report = generateBriefReport(emptyApp);
-    expect(report.trails).toBe(0);
-    expect(report.features.outputSchemas).toBe(false);
-    expect(report.features.examples).toBe(false);
-    expect(report.features.detours).toBe(false);
-    expect(report.features.provisions).toBe(false);
-  });
-});
-
-describe('trails survey detail', () => {
-  test('trail detail includes declared provisions, crossings, and intent', () => {
-    const detail = generateTrailDetail(helloTrail);
-    const parsed = structuredClone(detail) as TrailDetailReport;
-
-    expect(parsed.crosses).toEqual([]);
-    expect(parsed.intent).toBe('read');
-    expect(parsed.provisions).toEqual(['db.main']);
-  });
-});
-
-describe('trails survey provisions section', () => {
-  test('list output includes provision lifetime and health status', () => {
-    const report = generateSurveyList(app);
-    const parsed = structuredClone(report) as SurveyListReport;
-    const db = parsed.provisions.find((entry) => entry.id === 'db.main');
-
-    expect(parsed.provisionCount).toBe(1);
-    expect(db).toEqual({
-      description: null,
-      health: 'none',
-      id: 'db.main',
-      kind: 'provision',
-      lifetime: 'singleton',
-      usedBy: ['hello'],
-    });
-  });
-});
-
-describe('trails survey generate', () => {
-  test('delegates to topo export and writes a structured lock', async () => {
-    const dir = repoTempDir();
-
-    try {
-      writeSurveyAppFixture(dir);
-
-      const generated = expectOk(
-        await surveyTrail.blaze({ generate: true, module: './src/app.ts' }, {
-          cwd: dir,
-        } as never)
-      ) as {
-        readonly hash: string;
-        readonly lockPath: string;
-        readonly mapPath: string;
-      };
-
-      expect(generated.hash).toHaveLength(64);
-      expect(existsSync(join(dir, '.trails', '_trailhead.json'))).toBe(true);
-      expect(existsSync(join(dir, '.trails', 'trails.lock'))).toBe(true);
-      expect(
-        JSON.parse(readFileSync(join(dir, '.trails', 'trails.lock'), 'utf8'))
-      ).toMatchObject({
-        hash: generated.hash,
-        version: 1,
-      });
-    } finally {
-      rmSync(dir, { force: true, recursive: true });
-    }
-  });
-});