@amodalai/amodal 0.1.2

package/src/commands/build.ts

@@ -0,0 +1,135 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {writeFileSync} from 'node:fs';
+import {join, resolve} from 'node:path';
+import {execSync} from 'node:child_process';
+import type {CommandModule} from 'yargs';
+import {loadRepo, buildSnapshot, serializeSnapshot, snapshotSizeBytes} from '@amodalai/core';
+import {buildToolTemplates} from './build-tools.js';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+import {runValidate} from './validate.js';
+
+export interface BuildOptions {
+  cwd?: string;
+  output?: string;
+  tools?: boolean;
+}
+
+/**
+ * Get the current user from git config or fallback.
+ */
+function getCurrentUser(): string {
+  try {
+    return execSync('git config user.email', {encoding: 'utf-8'}).trim();
+  } catch {
+    return process.env['USER'] ?? 'unknown';
+  }
+}
+
+/**
+ * Get the current git commit SHA, or undefined if not in a git repo.
+ */
+function getGitSha(): string | undefined {
+  try {
+    return execSync('git rev-parse HEAD', {encoding: 'utf-8'}).trim();
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Build a deploy snapshot from the local repo.
+ *
+ * 1. Find repo root
+ * 2. Validate configuration
+ * 3. Load and resolve repo
+ * 4. Build snapshot
+ * 5. Write to output file
+ */
+export async function runBuild(options: BuildOptions = {}): Promise<number> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[build] ${msg}\n`);
+    return 1;
+  }
+
+  // Validate first
+  process.stderr.write(`[build] Validating ${repoPath}...\n`);
+  const errors = await runValidate({cwd: repoPath});
+  if (errors > 0) {
+    process.stderr.write(`[build] Validation failed with ${errors} error(s). Fix errors before building.\n`);
+    return 1;
+  }
+
+  // Load repo
+  process.stderr.write('[build] Loading repo...\n');
+  let repo;
+  try {
+    repo = await loadRepo({localPath: repoPath});
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[build] Failed to load repo: ${msg}\n`);
+    return 1;
+  }
+
+  // Build tool sandbox snapshots if requested
+  let buildManifest;
+  if (options.tools && repo.tools.length > 0) {
+    process.stderr.write(`[build] Building ${repo.tools.length} tool sandbox(es)...\n`);
+    buildManifest = await buildToolTemplates(repoPath, repo.tools);
+  } else if (options.tools && repo.tools.length === 0) {
+    process.stderr.write('[build] No tools found in tools/ directory\n');
+  }
+
+  // Build snapshot (includes tool metadata + build manifest if available)
+  const snapshot = buildSnapshot(repo, {
+    createdBy: getCurrentUser(),
+    source: 'cli',
+    commitSha: getGitSha(),
+    buildManifest,
+  });
+
+  // Serialize and write
+  const serialized = serializeSnapshot(snapshot);
+  const size = snapshotSizeBytes(serialized);
+  const outputPath = options.output
+    ? resolve(options.output)
+    : join(repoPath, 'resolved-config.json');
+
+  writeFileSync(outputPath, serialized);
+
+  process.stderr.write(`[build] Snapshot ${snapshot.deployId} written to ${outputPath}\n`);
+  process.stderr.write(`[build] Size: ${(size / 1024).toFixed(1)} KB\n`);
+  process.stderr.write(`[build] Connections: ${Object.keys(snapshot.connections).length}, Skills: ${snapshot.skills.length}, Automations: ${snapshot.automations.length}, Knowledge: ${snapshot.knowledge.length}, Tools: ${repo.tools.length}\n`);
+
+  return 0;
+}
+
+export const buildCommand: CommandModule = {
+  command: 'build',
+  describe: 'Build a deploy snapshot from the local repo',
+  builder: (yargs) =>
+    yargs
+      .option('output', {
+        type: 'string',
+        alias: 'o',
+        describe: 'Output file path (default: resolved-config.json)',
+      })
+      .option('tools', {
+        type: 'boolean',
+        describe: 'Build Daytona sandbox snapshots for custom tools',
+        default: false,
+      }),
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const code = await runBuild({output: argv['output'] as string | undefined, tools: argv['tools'] as boolean | undefined});
+    process.exit(code);
+  },
+};

package/src/commands/chat.ts

@@ -0,0 +1,147 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type http from 'node:http';
+import {createElement} from 'react';
+import {render} from 'ink';
+import type {CommandModule} from 'yargs';
+import {createLocalServer, createSnapshotServer} from '@amodalai/runtime';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+import {ChatApp} from '../ui/ChatApp.js';
+
+export interface ChatOptions {
+  cwd?: string;
+  url?: string;
+  config?: string;
+  tenantId?: string;
+  port?: number;
+  resume?: string;
+  fullscreen?: boolean;
+}
+
+/**
+ * Interactive chat session against a local repo, snapshot, or remote server.
+ *
+ * Three modes:
+ *   --url <remote>    → connect to an already-running server (no local boot)
+ *   --config <file>   → boot from a snapshot file
+ *   (default)         → boot from the local repo
+ */
+export async function runChat(options: ChatOptions): Promise<void> {
+  const tenantId = options.tenantId ?? 'cli-user';
+
+  // Mode 1: Connect to a remote server
+  if (options.url) {
+    const baseUrl = options.url.replace(/\/$/, '');
+    process.stderr.write(`[chat] Connecting to ${baseUrl}\n`);
+
+    const {waitUntilExit} = render(
+      createElement(ChatApp, {
+        baseUrl,
+        tenantId,
+        resumeSessionId: options.resume,
+        fullscreen: options.fullscreen,
+      }),
+    );
+    await waitUntilExit();
+    return;
+  }
+
+  // Mode 2 & 3: Boot a local server
+  const port = options.port ?? 0;
+  let serverInstance: {app: unknown; start: () => Promise<unknown>; stop: () => Promise<void>};
+
+  if (options.config) {
+    process.stderr.write(`[chat] Loading snapshot from ${options.config}\n`);
+    serverInstance = await createSnapshotServer({
+      snapshotPath: options.config,
+      port,
+      host: '127.0.0.1',
+    });
+  } else {
+    let repoPath: string;
+    try {
+      repoPath = findRepoRoot(options.cwd);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[chat] ${msg}\n`);
+      process.exit(1);
+    }
+
+    process.stderr.write(`[chat] Loading repo from ${repoPath}\n`);
+    serverInstance = await createLocalServer({
+      repoPath,
+      port,
+      host: '127.0.0.1',
+      hotReload: false,
+    });
+  }
+
+  const httpServer = await serverInstance.start();
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+  const addr = (httpServer as http.Server).address();
+  const actualPort = typeof addr === 'object' && addr !== null ? addr.port : port;
+  const baseUrl = `http://127.0.0.1:${actualPort}`;
+
+  const {waitUntilExit} = render(
+    createElement(ChatApp, {
+      baseUrl,
+      tenantId,
+      resumeSessionId: options.resume,
+      fullscreen: options.fullscreen,
+    }),
+  );
+  await waitUntilExit();
+  await serverInstance.stop();
+}
+
+export const chatCommand: CommandModule = {
+  command: 'chat',
+  describe: 'Interactive chat with the agent',
+  builder: (yargs) =>
+    yargs
+      .option('url', {
+        type: 'string',
+        describe: 'Connect to a remote server URL',
+      })
+      .option('config', {
+        type: 'string',
+        describe: 'Path to resolved-config.json snapshot',
+      })
+      .option('tenant-id', {
+        type: 'string',
+        describe: 'Tenant ID for the session',
+      })
+      .option('port', {
+        type: 'number',
+        describe: 'Port for the local server',
+      })
+      .option('resume', {
+        type: 'string',
+        describe: 'Resume a previous session by ID or "latest"',
+      })
+      .option('fullscreen', {
+        type: 'boolean',
+        describe: 'Use alternate buffer for full-screen mode',
+        default: false,
+      }),
+  handler: async (argv) => {
+    await runChat({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      url: argv['url'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      config: argv['config'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      tenantId: argv['tenantId'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      port: argv['port'] as number | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      resume: argv['resume'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      fullscreen: argv['fullscreen'] as boolean | undefined,
+    });
+  },
+};

package/src/commands/command-exports.test.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect} from 'vitest';
+import type {CommandModule} from 'yargs';
+
+import {connectCommand} from './connect.js';
+import {installPkgCommand} from './install-pkg.js';
+import {uninstallCommand} from './uninstall.js';
+import {listCommand} from './list.js';
+import {updateCommand} from './update.js';
+import {diffCommand} from './diff.js';
+import {searchCommand} from './search.js';
+import {publishCommand} from './publish.js';
+import {loginCommand} from './login.js';
+import {syncCommand} from './sync.js';
+
+import {initCommand} from './init.js';
+import {devCommand} from './dev.js';
+import {inspectCommand} from './inspect.js';
+import {validateCommand} from './validate.js';
+
+import {secretsCommand} from './secrets.js';
+import {deployCommand} from './deploy.js';
+import {buildCommand} from './build.js';
+import {dockerCommand} from './docker.js';
+import {rollbackCommand} from './rollback.js';
+import {deploymentsCommand} from './deployments.js';
+import {promoteCommand} from './promote.js';
+import {serveCommand} from './serve.js';
+import {statusCommand} from './status.js';
+import {auditCommand} from './audit.js';
+import {automationsCommand} from './automations.js';
+
+import {evalCommand} from './eval.js';
+import {experimentCommand} from './experiment.js';
+import {testQueryCommand} from './test-query.js';
+
+function assertValidCommandModule(mod: CommandModule, expectedCommand: string): void {
+  expect(mod.command).toBeDefined();
+  expect(String(mod.command).split(' ')[0]).toBe(expectedCommand);
+  expect(typeof mod.handler).toBe('function');
+}
+
+describe('command-exports', () => {
+  it('package management commands export valid CommandModules', () => {
+    assertValidCommandModule(connectCommand, 'connect');
+    assertValidCommandModule(installPkgCommand, 'install');
+    assertValidCommandModule(uninstallCommand, 'uninstall');
+    assertValidCommandModule(listCommand, 'list');
+    assertValidCommandModule(updateCommand, 'update');
+    assertValidCommandModule(diffCommand, 'diff');
+    assertValidCommandModule(searchCommand, 'search');
+    assertValidCommandModule(publishCommand, 'publish');
+    assertValidCommandModule(loginCommand, 'login');
+    assertValidCommandModule(syncCommand, 'sync');
+  });
+
+  it('project commands export valid CommandModules', () => {
+    assertValidCommandModule(initCommand, 'init');
+    assertValidCommandModule(devCommand, 'dev');
+    assertValidCommandModule(inspectCommand, 'inspect');
+    assertValidCommandModule(validateCommand, 'validate');
+  });
+
+  it('platform commands export valid CommandModules', () => {
+    assertValidCommandModule(secretsCommand, 'secrets');
+    assertValidCommandModule(deployCommand, 'deploy');
+    assertValidCommandModule(buildCommand, 'build');
+    assertValidCommandModule(dockerCommand, 'docker');
+    assertValidCommandModule(rollbackCommand, 'rollback');
+    assertValidCommandModule(deploymentsCommand, 'deployments');
+    assertValidCommandModule(promoteCommand, 'promote');
+    assertValidCommandModule(serveCommand, 'serve');
+    assertValidCommandModule(statusCommand, 'status');
+    assertValidCommandModule(auditCommand, 'audit');
+    assertValidCommandModule(automationsCommand, 'automations');
+  });
+
+  it('advanced commands export valid CommandModules', () => {
+    assertValidCommandModule(evalCommand, 'eval');
+    assertValidCommandModule(experimentCommand, 'experiment');
+    assertValidCommandModule(testQueryCommand, 'test-query');
+  });
+});