@amodalai/amodal 0.1.2

package/src/commands/init.test.ts

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, beforeEach, afterEach} from 'vitest';
+import {mkdtempSync, rmSync, existsSync, readFileSync} from 'node:fs';
+import {join} from 'node:path';
+import {tmpdir} from 'node:os';
+import {runInit} from './init.js';
+
+describe('runInit', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'amodal-init-'));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, {recursive: true, force: true});
+  });
+
+  it('should create project directory structure', async () => {
+    await runInit({
+      cwd: tempDir,
+      name: 'test-project',
+      provider: 'anthropic',
+    });
+
+    expect(existsSync(join(tempDir, 'amodal.json'))).toBe(true);
+    expect(existsSync(join(tempDir, 'connections'))).toBe(true);
+    expect(existsSync(join(tempDir, 'skills'))).toBe(true);
+    expect(existsSync(join(tempDir, 'knowledge'))).toBe(true);
+    expect(existsSync(join(tempDir, 'automations'))).toBe(true);
+    expect(existsSync(join(tempDir, 'evals'))).toBe(true);
+    expect(existsSync(join(tempDir, '.gitignore'))).toBe(true);
+    const gitignore = readFileSync(join(tempDir, '.gitignore'), 'utf-8');
+    expect(gitignore).toContain('amodal_packages/');
+    expect(gitignore).toContain('.env');
+  });
+
+  it('should write valid config.json', async () => {
+    await runInit({
+      cwd: tempDir,
+      name: 'my-agent',
+      provider: 'anthropic',
+    });
+
+    const config = JSON.parse(readFileSync(join(tempDir, 'amodal.json'), 'utf-8'));
+    expect(config['name']).toBe('my-agent');
+    expect(config['models']['main']['provider']).toBe('anthropic');
+  });
+
+  it('should write starter skill', async () => {
+    await runInit({cwd: tempDir});
+
+    const skill = readFileSync(join(tempDir, 'skills', 'SKILL.md'), 'utf-8');
+    expect(skill).toContain('general-analysis');
+  });
+
+  it('should write starter knowledge', async () => {
+    await runInit({cwd: tempDir});
+
+    const knowledge = readFileSync(join(tempDir, 'knowledge', 'domain.md'), 'utf-8');
+    expect(knowledge).toContain('Domain Knowledge');
+  });
+
+  it('should skip if config already exists', async () => {
+    // First run
+    await runInit({cwd: tempDir, name: 'first'});
+    const firstConfig = readFileSync(join(tempDir, 'amodal.json'), 'utf-8');
+
+    // Second run should skip
+    await runInit({cwd: tempDir, name: 'second'});
+    const secondConfig = readFileSync(join(tempDir, 'amodal.json'), 'utf-8');
+
+    expect(firstConfig).toBe(secondConfig);
+  });
+
+  it('should use OpenAI provider', async () => {
+    await runInit({
+      cwd: tempDir,
+      name: 'openai-project',
+      provider: 'openai',
+    });
+
+    const config = JSON.parse(readFileSync(join(tempDir, 'amodal.json'), 'utf-8'));
+    expect(config['models']['main']['provider']).toBe('openai');
+    expect(config['models']['main']['model']).toBe('gpt-4o');
+  });
+
+  it('should use Google provider', async () => {
+    await runInit({
+      cwd: tempDir,
+      provider: 'google',
+    });
+
+    const config = JSON.parse(readFileSync(join(tempDir, 'amodal.json'), 'utf-8'));
+    expect(config['models']['main']['provider']).toBe('google');
+  });
+
+  it('should default to anthropic provider', async () => {
+    await runInit({cwd: tempDir});
+
+    const config = JSON.parse(readFileSync(join(tempDir, 'amodal.json'), 'utf-8'));
+    expect(config['models']['main']['provider']).toBe('anthropic');
+  });
+});

package/src/commands/init.ts

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {existsSync, mkdirSync, writeFileSync} from 'node:fs';
+import {join} from 'node:path';
+import type {CommandModule} from 'yargs';
+import {generateConfigTemplate} from '../templates/config-template.js';
+import {generateSkillTemplate} from '../templates/skill-template.js';
+import {generateKnowledgeTemplate} from '../templates/knowledge-template.js';
+
+export interface InitOptions {
+  cwd?: string;
+  name?: string;
+  provider?: 'anthropic' | 'openai' | 'google';
+}
+
+/**
+ * Scaffolds a new amodal project in the current directory.
+ */
+export async function runInit(options: InitOptions = {}): Promise<void> {
+  const cwd = options.cwd ?? process.cwd();
+  const configPath = join(cwd, 'amodal.json');
+
+  if (existsSync(configPath)) {
+    process.stderr.write('[init] amodal.json already exists. Skipping.\n');
+    return;
+  }
+
+  const name = options.name || cwd.split('/').pop() || 'my-agent';
+  const provider = options.provider ?? 'anthropic';
+
+  // Create directory structure
+  const dirs = [
+    join(cwd, 'connections'),
+    join(cwd, 'skills'),
+    join(cwd, 'knowledge'),
+    join(cwd, 'automations'),
+    join(cwd, 'evals'),
+  ];
+
+  for (const dir of dirs) {
+    mkdirSync(dir, {recursive: true});
+  }
+
+  // Write amodal.json at repo root
+  writeFileSync(configPath, generateConfigTemplate({name, provider}));
+
+  // Write starter skill
+  writeFileSync(
+    join(cwd, 'skills', 'SKILL.md'),
+    generateSkillTemplate(),
+  );
+
+  // Write starter knowledge
+  writeFileSync(
+    join(cwd, 'knowledge', 'domain.md'),
+    generateKnowledgeTemplate(),
+  );
+
+  // Write .gitignore if it doesn't exist
+  const gitignorePath = join(cwd, '.gitignore');
+  if (!existsSync(gitignorePath)) {
+    writeFileSync(gitignorePath, '.amodal/\namodal_packages/\n.env\n.env.*\n');
+  }
+
+  process.stderr.write(`[init] Created project "${name}" (${provider})\n`);
+  process.stderr.write('[init] Next steps:\n');
+  process.stderr.write('  1. Add a connection:  amodal connect <name>\n');
+  process.stderr.write('  2. Validate config:   amodal validate\n');
+  process.stderr.write('  3. Start dev server:  amodal dev\n');
+}
+
+export const initCommand: CommandModule = {
+  command: 'init',
+  describe: 'Initialize a new amodal project',
+  builder: (yargs) =>
+    yargs
+      .option('name', {
+        type: 'string',
+        describe: 'Project name (defaults to directory name)',
+      })
+      .option('provider', {
+        type: 'string',
+        choices: ['anthropic', 'openai', 'google'] as const,
+        describe: 'LLM provider (default: anthropic)',
+      }),
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const provider = argv['provider'] as InitOptions['provider'];
+    await runInit({
+      name: argv['name'] ? String(argv['name']) : undefined,
+      provider,
+    });
+  },
+};

package/src/commands/inspect.test.ts

@@ -0,0 +1,234 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {describe, it, expect, vi, beforeEach, afterEach} from 'vitest';
+
+const mockFindRepoRoot = vi.fn(() => '/test/repo');
+const mockReadLockFile = vi.fn();
+const mockResolveAllPackages = vi.fn();
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: mockFindRepoRoot,
+}));
+
+vi.mock('@amodalai/core', () => ({
+  readLockFile: mockReadLockFile,
+  resolveAllPackages: mockResolveAllPackages,
+  loadRepo: vi.fn().mockResolvedValue({
+    config: {models: {main: {provider: 'anthropic', model: 'test'}}},
+    connections: new Map([['crm', {spec: {auth: {type: 'bearer'}}, surface: [{}, {}]}]]),
+    skills: [{name: 'triage'}],
+    automations: [],
+    knowledge: [],
+    evals: [],
+    tools: [],
+  }),
+  setupSession: vi.fn(() => ({
+    compiledContext: {
+      systemPrompt: 'test prompt',
+      tokenUsage: {total: 100000, used: 1000, remaining: 99000, sectionBreakdown: {}},
+      sections: [
+        {name: 'core', content: 'Core content here', tokens: 500, priority: 10, trimmed: false},
+        {name: 'skills', content: 'Skill content here', tokens: 500, priority: 5, trimmed: false},
+      ],
+    },
+    exploreContext: {
+      systemPrompt: 'explore prompt',
+      tokenUsage: {total: 100000, used: 400, remaining: 99600, sectionBreakdown: {}},
+      sections: [{name: 'explore-core', content: 'x', tokens: 400, priority: 10, trimmed: false}],
+    },
+    repo: {
+      connections: new Map([['crm', {spec: {auth: {type: 'bearer'}}, surface: [{}, {}]}]]),
+    },
+  })),
+}));
+
+describe('runInspect', () => {
+  let stdoutOutput: string[];
+  let stderrOutput: string[];
+  let origStdout: typeof process.stdout.write;
+  let origStderr: typeof process.stderr.write;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFindRepoRoot.mockReturnValue('/test/repo');
+    stdoutOutput = [];
+    stderrOutput = [];
+    origStdout = process.stdout.write;
+    origStderr = process.stderr.write;
+    process.stdout.write = ((chunk: string) => {
+      stdoutOutput.push(String(chunk));
+      return true;
+    }) as typeof process.stdout.write;
+    process.stderr.write = ((chunk: string) => {
+      stderrOutput.push(String(chunk));
+      return true;
+    }) as typeof process.stderr.write;
+  });
+
+  afterEach(() => {
+    process.stdout.write = origStdout;
+    process.stderr.write = origStderr;
+  });
+
+  it('should output section information', async () => {
+    const {runInspect} = await import('./inspect.js');
+    await runInspect();
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('Compiled Context');
+    expect(output).toContain('core');
+  });
+
+  it('should output connections', async () => {
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({connections: true});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('crm');
+  });
+
+  it('should output explore context', async () => {
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({explore: true});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('Explore Context');
+  });
+
+  it('should output tools', async () => {
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({tools: true});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('request');
+    expect(output).toContain('explore');
+  });
+
+  it('should handle repo not found', async () => {
+    mockFindRepoRoot.mockImplementation(() => {
+      throw new Error('Not found');
+    });
+
+    const {runInspect} = await import('./inspect.js');
+    await runInspect();
+
+    const output = stderrOutput.join('');
+    expect(output).toContain('Not found');
+  });
+
+  it('should show section content when context flag is set', async () => {
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({context: true});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('Core content here');
+  });
+
+  // Resolved package tests
+  it('should show resolved packages when resolved flag set', async () => {
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockResolveAllPackages.mockResolvedValue({
+      connections: new Map([['salesforce', {surface: [{}, {}, {}], spec: {auth: {type: 'bearer'}}}]]),
+      skills: [{name: 'triage', body: 'Triage methodology content'}],
+      automations: [{name: 'daily-scan'}],
+      knowledge: [],
+      warnings: [],
+    });
+
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({resolved: true});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('Resolved Packages');
+    expect(output).toContain('salesforce');
+    expect(output).toContain('triage');
+  });
+
+  it('should filter by scope', async () => {
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockResolveAllPackages.mockResolvedValue({
+      connections: new Map([
+        ['salesforce', {surface: [{}, {}], spec: {auth: {type: 'bearer'}}}],
+        ['stripe', {surface: [{}], spec: {auth: {type: 'api_key'}}}],
+      ]),
+      skills: [{name: 'triage', body: 'content'}],
+      automations: [],
+      knowledge: [],
+      warnings: [],
+    });
+
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({resolved: true, scope: 'connections/salesforce'});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('salesforce');
+    expect(output).not.toContain('stripe');
+  });
+
+  it('should show no lock file message when resolved without lock', async () => {
+    mockReadLockFile.mockResolvedValue(null);
+
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({resolved: true});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('No lock file found');
+  });
+
+  it('should show resolution warnings', async () => {
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockResolveAllPackages.mockResolvedValue({
+      connections: new Map(),
+      skills: [],
+      automations: [],
+      knowledge: [],
+      warnings: ['Package connection/old is in lock file but not installed'],
+    });
+
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({resolved: true});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('Warnings');
+    expect(output).toContain('not installed');
+  });
+
+  it('should show connection details in resolved view', async () => {
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockResolveAllPackages.mockResolvedValue({
+      connections: new Map([['crm', {surface: [{}, {}], spec: {auth: {type: 'oauth2'}}}]]),
+      skills: [],
+      automations: [],
+      knowledge: [],
+      warnings: [],
+    });
+
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({resolved: true});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('Endpoints: 2');
+    expect(output).toContain('oauth2');
+  });
+
+  it('should show skill body length in resolved view', async () => {
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockResolveAllPackages.mockResolvedValue({
+      connections: new Map(),
+      skills: [{name: 'investigate', body: 'A'.repeat(500)}],
+      automations: [],
+      knowledge: [],
+      warnings: [],
+    });
+
+    const {runInspect} = await import('./inspect.js');
+    await runInspect({resolved: true});
+
+    const output = stdoutOutput.join('');
+    expect(output).toContain('500 chars');
+  });
+});

package/src/commands/inspect.ts

@@ -0,0 +1,157 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {loadRepo, setupSession, readLockFile, resolveAllPackages} from '@amodalai/core';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+export interface InspectOptions {
+  cwd?: string;
+  context?: boolean;
+  explore?: boolean;
+  tools?: boolean;
+  connections?: boolean;
+  resolved?: boolean;
+  scope?: string;
+}
+
+/**
+ * Loads the repo, runs setupSession(), and prints the compiled
+ * prompt with section headers and token counts.
+ */
+export async function runInspect(options: InspectOptions = {}): Promise<void> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[inspect] ${msg}\n`);
+    return;
+  }
+
+  process.stderr.write(`[inspect] Loading repo from ${repoPath}\n`);
+
+  const repo = await loadRepo({localPath: repoPath});
+  const runtime = setupSession({repo});
+
+  const showAll = !options.context && !options.explore && !options.tools && !options.connections && !options.resolved;
+
+  if (showAll || options.context) {
+    process.stdout.write('\n=== Compiled Context ===\n');
+    process.stdout.write(`Total tokens: ${runtime.compiledContext.tokenUsage.used}/${runtime.compiledContext.tokenUsage.total}\n`);
+    process.stdout.write(`Remaining: ${runtime.compiledContext.tokenUsage.remaining}\n\n`);
+
+    for (const section of runtime.compiledContext.sections) {
+      const trimLabel = section.trimmed ? ' [TRIMMED]' : '';
+      process.stdout.write(`--- ${section.name} (${section.tokens} tokens, priority ${section.priority})${trimLabel} ---\n`);
+      if (options.context) {
+        process.stdout.write(section.content + '\n\n');
+      }
+    }
+  }
+
+  if (showAll || options.explore) {
+    process.stdout.write('\n=== Explore Context ===\n');
+    process.stdout.write(`Total tokens: ${runtime.exploreContext.tokenUsage.used}/${runtime.exploreContext.tokenUsage.total}\n\n`);
+
+    for (const section of runtime.exploreContext.sections) {
+      process.stdout.write(`--- ${section.name} (${section.tokens} tokens) ---\n`);
+    }
+  }
+
+  if (showAll || options.connections) {
+    process.stdout.write('\n=== Connections ===\n');
+    for (const [name, conn] of repo.connections) {
+      process.stdout.write(`  ${name}: ${conn.surface.length} endpoints, auth=${conn.spec.auth?.type ?? 'none'}\n`);
+    }
+  }
+
+  if (showAll || options.tools) {
+    process.stdout.write('\n=== Available Tools ===\n');
+    process.stdout.write('  request (HTTP to connected systems)\n');
+    process.stdout.write('  explore (delegate to sub-agent)\n');
+    process.stdout.write('  enter_plan_mode / exit_plan_mode\n');
+  }
+
+  if (options.resolved) {
+    process.stdout.write('\n=== Resolved Packages ===\n');
+
+    const lockFile = await readLockFile(repoPath);
+    if (!lockFile) {
+      process.stdout.write('  No lock file found.\n');
+    } else {
+      const resolved = await resolveAllPackages({repoPath, lockFile});
+
+      // Filter by scope if given
+      const scopeParts = options.scope?.split('/');
+      const scopeType = scopeParts?.[0];
+      const scopeName = scopeParts?.[1];
+
+      if (!scopeType || scopeType === 'connections') {
+        for (const [name, conn] of resolved.connections) {
+          if (scopeName && name !== scopeName) continue;
+          process.stdout.write(`\n  Connection: ${name}\n`);
+          process.stdout.write(`    Endpoints: ${conn.surface.length}\n`);
+          process.stdout.write(`    Auth: ${conn.spec.auth?.type ?? 'none'}\n`);
+        }
+      }
+
+      if (!scopeType || scopeType === 'skills') {
+        for (const skill of resolved.skills) {
+          if (scopeName && skill.name !== scopeName) continue;
+          process.stdout.write(`\n  Skill: ${skill.name}\n`);
+          process.stdout.write(`    Body: ${skill.body.length} chars\n`);
+        }
+      }
+
+      if (!scopeType || scopeType === 'automations') {
+        for (const auto of resolved.automations) {
+          if (scopeName && auto.name !== scopeName) continue;
+          process.stdout.write(`\n  Automation: ${auto.name}\n`);
+        }
+      }
+
+      // Print warnings
+      if (resolved.warnings.length > 0) {
+        process.stdout.write('\n  Warnings:\n');
+        for (const warning of resolved.warnings) {
+          process.stdout.write(`    - ${warning}\n`);
+        }
+      }
+    }
+  }
+
+  process.stdout.write('\n');
+}
+
+export const inspectCommand: CommandModule = {
+  command: 'inspect',
+  describe: 'Inspect compiled prompt and runtime context',
+  builder: (yargs) =>
+    yargs
+      .option('context', {type: 'boolean', default: false, describe: 'Show full context content'})
+      .option('explore', {type: 'boolean', default: false, describe: 'Show explore context'})
+      .option('tools', {type: 'boolean', default: false, describe: 'Show available tools'})
+      .option('connections', {type: 'boolean', default: false, describe: 'Show connections'})
+      .option('resolved', {type: 'boolean', default: false, describe: 'Show resolved packages'})
+      .option('scope', {type: 'string', describe: 'Filter resolved by scope (e.g. connections/name)'}),
+  handler: async (argv) => {
+    await runInspect({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      context: argv['context'] as boolean,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      explore: argv['explore'] as boolean,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      tools: argv['tools'] as boolean,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      connections: argv['connections'] as boolean,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      resolved: argv['resolved'] as boolean,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      scope: argv['scope'] as string | undefined,
+    });
+  },
+};