@amodalai/amodal 0.1.2

package/src/commands/diff.ts

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {
+  ensureNpmContext,
+  getLockEntry,
+  makePackageRef,
+  npmView,
+  readPackageFile,
+  listPackageFiles,
+  getPackageDir,
+} from '@amodalai/core';
+import type {PackageType} from '@amodalai/core';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+export interface DiffOptions {
+  cwd?: string;
+  type: PackageType;
+  name: string;
+}
+
+/**
+ * Show diff between installed version and latest available.
+ * Returns 0 on success, 1 on error.
+ */
+export async function runDiff(options: DiffOptions): Promise<number> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[diff] ${msg}\n`);
+    return 1;
+  }
+
+  const paths = await ensureNpmContext(repoPath);
+  const ref = makePackageRef(options.type, options.name);
+
+  // Check if installed
+  const lockEntry = await getLockEntry(repoPath, options.type, options.name);
+  if (!lockEntry) {
+    process.stderr.write(`[diff] Package ${ref.key} is not installed.\n`);
+    return 1;
+  }
+
+  // Get latest version info
+  let latestVersion: string;
+  try {
+    const viewResult = await npmView(paths, ref.npmName);
+    latestVersion = viewResult.version;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[diff] Failed to query registry: ${msg}\n`);
+    return 1;
+  }
+
+  if (latestVersion === lockEntry.version) {
+    process.stderr.write(`[diff] ${ref.npmName}@${lockEntry.version} is already the latest version.\n`);
+    return 0;
+  }
+
+  process.stderr.write(`[diff] Comparing ${ref.npmName}: ${lockEntry.version} (installed) → ${latestVersion} (latest)\n`);
+
+  // Get installed package directory
+  const packageDir = await getPackageDir(repoPath, ref);
+  if (!packageDir) {
+    process.stderr.write(`[diff] Package ${ref.key} is in lock file but not installed on disk.\n`);
+    return 1;
+  }
+
+  // List installed files
+  let installedFiles: string[];
+  try {
+    installedFiles = await listPackageFiles(packageDir);
+  } catch {
+    installedFiles = [];
+  }
+
+  // Print diff report
+  process.stdout.write(`\n  ${ref.npmName}\n`);
+  process.stdout.write(`  Installed: ${lockEntry.version}\n`);
+  process.stdout.write(`  Latest:    ${latestVersion}\n\n`);
+
+  // Show file-level summary
+  process.stdout.write('  Files in installed version:\n');
+  for (const file of installedFiles) {
+    const content = await readPackageFile(packageDir, file);
+    if (content !== null) {
+      const lineCount = content.split('\n').length;
+      let detail = `${lineCount} lines`;
+
+      // Add type-specific details
+      if (file === 'surface.md') {
+        const endpointCount = (content.match(/^##\s/gm) ?? []).length;
+        detail += `, ${endpointCount} endpoint${endpointCount === 1 ? '' : 's'}`;
+      } else if (file === 'spec.json') {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+          const spec = JSON.parse(content) as Record<string, unknown>;
+          const keys = Object.keys(spec);
+          detail += `, keys: ${keys.join(', ')}`;
+        } catch {
+          // Not valid JSON
+        }
+      } else if (file === 'access.json') {
+        try {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+          const access = JSON.parse(content) as Record<string, unknown>;
+          const ruleCount = Object.keys(access).length;
+          detail += `, ${ruleCount} rule${ruleCount === 1 ? '' : 's'}`;
+        } catch {
+          // Not valid JSON
+        }
+      } else if (file === 'entities.md') {
+        const sectionCount = (content.match(/^##\s/gm) ?? []).length;
+        detail += `, ${sectionCount} entit${sectionCount === 1 ? 'y' : 'ies'}`;
+      }
+
+      process.stdout.write(`    ${file} (${detail})\n`);
+    }
+  }
+
+  process.stdout.write(`\n  Run \`amodal update ${options.type} ${options.name}\` to upgrade.\n\n`);
+  return 0;
+}
+
+export const diffCommand: CommandModule = {
+  command: 'diff <type> <name>',
+  describe: 'Show diff between installed and latest version',
+  builder: (yargs) =>
+    yargs
+      .positional('type', {type: 'string', demandOption: true, choices: ['connection', 'skill', 'automation', 'knowledge'] as const, describe: 'Package type'})
+      .positional('name', {type: 'string', demandOption: true, describe: 'Package name'}),
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const code = await runDiff({type: argv['type'] as PackageType, name: argv['name'] as string});
+    process.exit(code);
+  },
+};

package/src/commands/docker.ts

@@ -0,0 +1,232 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {existsSync, readFileSync, writeFileSync} from 'node:fs';
+import {join} from 'node:path';
+import {execSync} from 'node:child_process';
+import type {CommandModule} from 'yargs';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+import {generateDockerfile} from '../templates/dockerfile-template.js';
+import {generateCompose} from '../templates/compose-template.js';
+import {extractEnvVars} from '../templates/env-template.js';
+
+export interface DockerOptions {
+  cwd?: string;
+  subcommand: 'init' | 'check' | 'build';
+  tag?: string;
+}
+
+/**
+ * Docker tooling for self-hosted runtime containerization.
+ *
+ * - `init`: Generate Dockerfile, docker-compose.yml, .env.production
+ * - `check`: Validate repo + env vars + Docker availability
+ * - `build`: Run `docker build` and tag the image
+ */
+export async function runDocker(options: DockerOptions): Promise<void> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[docker] ${msg}\n`);
+    process.exit(1);
+  }
+
+  switch (options.subcommand) {
+    case 'init':
+      await dockerInit(repoPath);
+      break;
+    case 'check':
+      await dockerCheck(repoPath);
+      break;
+    case 'build':
+      await dockerBuild(repoPath, options.tag);
+      break;
+    default:
+      process.stderr.write(`[docker] Unknown subcommand: ${options.subcommand}\n`);
+      process.exit(1);
+  }
+}
+
+async function dockerInit(repoPath: string): Promise<void> {
+  const configPath = join(repoPath, 'amodal.json');
+  if (!existsSync(configPath)) {
+    process.stderr.write('[docker] No amodal.json found. Run `amodal init` first.\n');
+    process.exit(1);
+  }
+
+  const configStr = readFileSync(configPath, 'utf-8');
+  let config: Record<string, unknown>;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- parsing config JSON
+    config = JSON.parse(configStr) as Record<string, unknown>;
+  } catch {
+    process.stderr.write('[docker] Failed to parse amodal.json.\n');
+    process.exit(1);
+  }
+
+  // Generate Dockerfile
+  const dockerfilePath = join(repoPath, 'Dockerfile');
+  if (existsSync(dockerfilePath)) {
+    process.stderr.write('[docker] Dockerfile already exists, skipping.\n');
+  } else {
+    writeFileSync(dockerfilePath, generateDockerfile());
+    process.stderr.write('[docker] Generated Dockerfile\n');
+  }
+
+  // Generate docker-compose.yml
+  const composePath = join(repoPath, 'docker-compose.yml');
+  if (existsSync(composePath)) {
+    process.stderr.write('[docker] docker-compose.yml already exists, skipping.\n');
+  } else {
+    const name = typeof config['name'] === 'string' ? config['name'] : 'amodal-agent';
+    writeFileSync(composePath, generateCompose(name));
+    process.stderr.write('[docker] Generated docker-compose.yml\n');
+  }
+
+  // Generate .env.production
+  const envPath = join(repoPath, '.env.production');
+  if (existsSync(envPath)) {
+    process.stderr.write('[docker] .env.production already exists, skipping.\n');
+  } else {
+    const envVars = extractEnvVars(configStr);
+
+    // Also check spec.json files
+    const specPath = join(repoPath, 'connections');
+    if (existsSync(specPath)) {
+      try {
+        const {readdirSync} = await import('node:fs');
+        const dirs = readdirSync(specPath);
+        for (const dir of dirs) {
+          const specFile = join(specPath, dir, 'spec.json');
+          if (existsSync(specFile)) {
+            const specStr = readFileSync(specFile, 'utf-8');
+            const specVars = extractEnvVars(specStr);
+            for (const v of specVars) {
+              if (!envVars.includes(v)) {
+                envVars.push(v);
+              }
+            }
+          }
+        }
+      } catch {
+        // Ignore scan errors
+      }
+    }
+
+    const envContent = envVars.map((v) => `${v}=`).join('\n') + '\n';
+    writeFileSync(envPath, envContent);
+    process.stderr.write(`[docker] Generated .env.production with ${envVars.length} variables\n`);
+  }
+
+  process.stderr.write('[docker] Init complete. Review generated files before deploying.\n');
+}
+
+async function dockerCheck(repoPath: string): Promise<void> {
+  let hasErrors = false;
+
+  // Check config exists
+  const configPath = join(repoPath, 'amodal.json');
+  if (!existsSync(configPath)) {
+    process.stderr.write('[docker] ✗ Missing amodal.json\n');
+    hasErrors = true;
+  } else {
+    process.stderr.write('[docker] ✓ amodal.json found\n');
+  }
+
+  // Check Dockerfile
+  if (!existsSync(join(repoPath, 'Dockerfile'))) {
+    process.stderr.write('[docker] ✗ Missing Dockerfile (run `amodal docker init`)\n');
+    hasErrors = true;
+  } else {
+    process.stderr.write('[docker] ✓ Dockerfile found\n');
+  }
+
+  // Check Docker
+  try {
+    execSync('docker --version', {stdio: 'pipe'});
+    process.stderr.write('[docker] ✓ Docker available\n');
+  } catch {
+    process.stderr.write('[docker] ✗ Docker not found. Install Docker to build images.\n');
+    hasErrors = true;
+  }
+
+  // Check env vars
+  const configStr = existsSync(configPath) ? readFileSync(configPath, 'utf-8') : '';
+  const envVars = extractEnvVars(configStr);
+  const missing = envVars.filter((v) => !process.env[v]);
+  if (missing.length > 0) {
+    process.stderr.write(`[docker] ⚠ ${missing.length} env vars not set: ${missing.join(', ')}\n`);
+  } else if (envVars.length > 0) {
+    process.stderr.write(`[docker] ✓ All ${envVars.length} env vars set\n`);
+  }
+
+  if (hasErrors) {
+    process.stderr.write('[docker] Check failed.\n');
+    process.exit(1);
+  } else {
+    process.stderr.write('[docker] All checks passed.\n');
+  }
+}
+
+async function dockerBuild(repoPath: string, tag?: string): Promise<void> {
+  const configPath = join(repoPath, 'amodal.json');
+  if (!existsSync(configPath)) {
+    process.stderr.write('[docker] No amodal.json found.\n');
+    process.exit(1);
+  }
+
+  let imageName: string;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- parsing config JSON
+    const config = JSON.parse(readFileSync(configPath, 'utf-8')) as Record<string, unknown>;
+    imageName = typeof config['name'] === 'string' ? config['name'] : 'amodal-agent';
+  } catch {
+    imageName = 'amodal-agent';
+  }
+
+  const imageTag = tag ?? 'latest';
+  const fullTag = `${imageName}:${imageTag}`;
+
+  process.stderr.write(`[docker] Building ${fullTag}...\n`);
+
+  try {
+    execSync(`docker build -t ${fullTag} .`, {
+      cwd: repoPath,
+      stdio: 'inherit',
+    });
+    process.stderr.write(`[docker] Built ${fullTag}\n`);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[docker] Build failed: ${msg}\n`);
+    process.exit(1);
+  }
+}
+
+export const dockerCommand: CommandModule = {
+  command: 'docker <subcommand>',
+  describe: 'Docker tooling for self-hosted deployment',
+  builder: (yargs) =>
+    yargs
+      .positional('subcommand', {
+        type: 'string',
+        demandOption: true,
+        choices: ['init', 'check', 'build'] as const,
+      })
+      .option('tag', {
+        type: 'string',
+        describe: 'Image tag for build',
+      }),
+  handler: async (argv) => {
+    await runDocker({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      subcommand: argv['subcommand'] as 'init' | 'check' | 'build',
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      tag: argv['tag'] as string | undefined,
+    });
+  },
+};

package/src/commands/eval.test.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi, beforeEach} from 'vitest';
+
+vi.mock('@amodalai/runtime', () => ({
+  createLocalServer: vi.fn().mockResolvedValue({
+    start: vi.fn().mockResolvedValue({address: () => ({port: 9999})}),
+    stop: vi.fn().mockResolvedValue(undefined),
+  }),
+}));
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: vi.fn(() => '/test/repo'),
+}));
+
+const mockLoadRepo = vi.fn();
+const mockRunEvalSuite = vi.fn();
+vi.mock('@amodalai/core', async () => {
+  const actual = await vi.importActual('@amodalai/core');
+  return {
+    ...actual,
+    loadRepoFromDisk: mockLoadRepo,
+    runEvalSuite: mockRunEvalSuite,
+  };
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  // Mock fetch for SSE responses
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+    ok: true,
+    text: vi.fn().mockResolvedValue('data: {"type":"text_delta","content":"test response"}\n'),
+  }));
+});
+
+describe('runEval', () => {
+  it('exits early when no evals found', async () => {
+    mockLoadRepo.mockResolvedValue({
+      evals: [],
+      config: {name: 'test', models: {main: {provider: 'anthropic', model: 'test'}}},
+    });
+
+    const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    const {runEval} = await import('./eval.js');
+
+    await runEval({cwd: '/test'});
+    expect(stderrSpy).toHaveBeenCalledWith(expect.stringContaining('No evals found'));
+
+    stderrSpy.mockRestore();
+  });
+
+  it('runs eval suite and outputs table', async () => {
+    mockLoadRepo.mockResolvedValue({
+      evals: [{name: 'test-1', title: 'Test', description: '', setup: {}, query: 'hi', assertions: [{text: 'work', negated: false}], raw: '', location: '/test'}],
+      config: {name: 'test', models: {main: {provider: 'anthropic', model: 'test'}}},
+    });
+
+    // Mock the generator
+    async function* mockGen() {
+      yield {type: 'eval_start' as const, evalName: 'test-1', current: 1, total: 1};
+      yield {type: 'eval_complete' as const, evalName: 'test-1', passed: true, current: 1, total: 1};
+      yield {type: 'suite_complete' as const};
+      return {
+        results: [{eval: {name: 'test-1'}, passed: true, assertions: [{passed: true, text: 'work', negated: false, reason: 'ok'}], response: 'ok', toolCalls: [], durationMs: 100}],
+        totalPassed: 1,
+        totalFailed: 0,
+        totalSkipped: 0,
+        totalDurationMs: 100,
+        timestamp: new Date().toISOString(),
+      };
+    }
+    mockRunEvalSuite.mockReturnValue(mockGen());
+
+    const stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    const stderrSpy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const {runEval} = await import('./eval.js');
+    await runEval({cwd: '/test'});
+
+    expect(stdoutSpy).toHaveBeenCalled();
+    stdoutSpy.mockRestore();
+    stderrSpy.mockRestore();
+  });
+});