@amodalai/amodal 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amodalai/amodal",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Amodal CLI",
   "license": "MIT",
   "repository": {
@@ -30,10 +30,10 @@
     "semver": "^7.6.0",
     "yargs": "^17.7.2",
     "zod": "^4.3.6",
-    "@amodalai/core": "0.2.1",
-    "@amodalai/types": "0.2.1",
-    "@amodalai/runtime": "0.2.1",
-    "@amodalai/runtime-app": "0.2.1"
+    "@amodalai/types": "0.2.2",
+    "@amodalai/core": "0.2.2",
+    "@amodalai/runtime": "0.2.2",
+    "@amodalai/runtime-app": "0.2.2"
   },
   "devDependencies": {
     "@types/node": "^20.11.24",

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

@@ -47,6 +47,6 @@ describe('command-exports', () => {
   });
 
   it('amodalCommands has expected count', () => {
-    expect(amodalCommands).toHaveLength(11);
+    expect(amodalCommands).toHaveLength(12);
   });
 });

package/src/commands/connect-channel.ts

@@ -0,0 +1,197 @@
+/**
+ * @license
+ * Copyright 2026 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+/**
+ * `amodal connect channel <name>` — install a channel package and run
+ * its interactive setup flow (prompt for credentials, set webhooks, etc.).
+ */
+
+ 
+import {findRepoRoot} from '../shared/repo-discovery.js';
+import type {CommandModule} from 'yargs';
+import {readFileSync, writeFileSync, existsSync} from 'node:fs';
+import path from 'node:path';
+import {pathToFileURL} from 'node:url';
+import prompts from 'prompts';
+import {ensurePackageJson, pmAdd, toNpmName} from '@amodalai/core';
+import type {ChannelPlugin, ChannelSetupContext} from '@amodalai/types';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type -- yargs CommandModule default generic
+export const connectChannelCommand: CommandModule<{}, {name: string; 'webhook-url'?: string}> = {
+  command: 'channel <name>',
+  describe: 'Connect a messaging channel (install + setup)',
+  builder: (yargs) =>
+    yargs
+      .positional('name', {type: 'string', demandOption: true, describe: 'Channel package name or short name'})
+      .option('webhook-url', {type: 'string', describe: 'Public webhook URL for this channel'}),
+  handler: async (argv) => {
+    const code = await runConnectChannel({name: argv.name, webhookUrl: argv['webhook-url']});
+    process.exit(code);
+  },
+};
+
+interface ConnectChannelOptions {
+  name: string;
+  cwd?: string;
+  webhookUrl?: string;
+}
+
+async function runConnectChannel(options: ConnectChannelOptions): Promise<number> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[connect channel] ${msg}\n`);
+    return 1;
+  }
+
+  const npmName = toNpmName(options.name);
+
+  // Step 1: Install if not present
+  const packageDir = path.join(repoPath, 'node_modules', ...npmName.split('/'));
+  let alreadyInstalled = false;
+  try {
+    alreadyInstalled = existsSync(path.join(packageDir, 'package.json'));
+  } catch {
+    // Not installed
+  }
+
+  if (!alreadyInstalled) {
+    process.stderr.write(`[connect channel] Installing ${npmName}...\n`);
+    try {
+      ensurePackageJson(repoPath, 'amodal-project');
+      await pmAdd(repoPath, npmName);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[connect channel] Install failed: ${msg}\n`);
+      return 1;
+    }
+  } else {
+    process.stderr.write(`[connect channel] ${npmName} already installed.\n`);
+  }
+
+  // Step 2: Load the plugin
+  const plugin = await loadChannelPlugin(packageDir, npmName);
+  if (!plugin) return 1;
+
+  // Step 3: Add to packages array in amodal.json if not present
+  const configPath = path.join(repoPath, 'amodal.json');
+  if (!existsSync(configPath)) {
+    process.stderr.write('[connect channel] No amodal.json found. Run `amodal init` first.\n');
+    return 1;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- parsing external JSON
+  const config = JSON.parse(readFileSync(configPath, 'utf-8')) as Record<string, unknown>;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- config.packages is string[]
+  const packages = (config['packages'] ?? []) as string[];
+  if (!packages.includes(npmName)) {
+    packages.push(npmName);
+    config['packages'] = packages;
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    process.stderr.write(`[connect channel] Added ${npmName} to amodal.json packages.\n`);
+  }
+
+  // Step 4: Run plugin setup if available
+  if (!plugin.setup) {
+    process.stderr.write(`[connect channel] ${plugin.channelType} connected. No interactive setup available.\n`);
+    return 0;
+  }
+
+  const context = buildSetupContext(repoPath, configPath, config, options.webhookUrl);
+  try {
+    await plugin.setup(context);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[connect channel] Setup failed: ${msg}\n`);
+    return 1;
+  }
+
+  process.stderr.write(`\n✅ Channel "${plugin.channelType}" connected and configured.\n`);
+  return 0;
+}
+
+async function loadChannelPlugin(
+  packageDir: string,
+  npmName: string,
+): Promise<ChannelPlugin | null> {
+  const pkgJsonPath = path.join(packageDir, 'package.json');
+  if (!existsSync(pkgJsonPath)) {
+    process.stderr.write(`[connect channel] Package "${npmName}" not found in node_modules.\n`);
+    return null;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- parsing external JSON
+  const pkgJson = JSON.parse(readFileSync(pkgJsonPath, 'utf-8')) as Record<string, unknown>;
+  const mainField = String(pkgJson['main'] ?? 'dist/index.js');
+  const entryPath = path.resolve(packageDir, mainField);
+
+  if (!entryPath.startsWith(path.resolve(packageDir))) {
+    process.stderr.write(`[connect channel] Package "${npmName}" has invalid main field.\n`);
+    return null;
+  }
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- dynamic import
+    const mod = await import(pathToFileURL(entryPath).href) as {default?: unknown};
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- validating shape below
+    const plugin = mod.default as ChannelPlugin | undefined;
+
+    if (!plugin || typeof plugin.channelType !== 'string' || typeof plugin.createAdapter !== 'function') {
+      process.stderr.write(`[connect channel] Package "${npmName}" does not export a valid ChannelPlugin.\n`);
+      return null;
+    }
+    return plugin;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[connect channel] Failed to load plugin: ${msg}\n`);
+    return null;
+  }
+}
+
+function buildSetupContext(
+  repoPath: string,
+  configPath: string,
+  config: Record<string, unknown>,
+  webhookUrl?: string,
+): ChannelSetupContext {
+  return {
+    repoPath,
+    config,
+    webhookUrl,
+    writeEnv: async (key: string, value: string) => {
+      const envPath = path.join(repoPath, '.env');
+      const existing = existsSync(envPath) ? readFileSync(envPath, 'utf-8') : '';
+      const lines = existing.split('\n');
+      const idx = lines.findIndex((l) => l.startsWith(`${key}=`));
+      if (idx >= 0) {
+        lines[idx] = `${key}=${value}`;
+      } else {
+        lines.push(`${key}=${value}`);
+      }
+      writeFileSync(envPath, lines.join('\n'));
+    },
+    updateConfig: async (patch: Record<string, unknown>) => {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- parsing project config
+      const current = JSON.parse(readFileSync(configPath, 'utf-8')) as Record<string, unknown>;
+      Object.assign(current, patch);
+      writeFileSync(configPath, JSON.stringify(current, null, 2) + '\n');
+    },
+    prompt: async (message: string, options?: {secret?: boolean; default?: string}) => {
+      const response = await prompts({
+        type: options?.secret ? 'password' : 'text',
+        name: 'value',
+        message,
+        initial: options?.default,
+      });
+      if (response.value === undefined) {
+        throw new Error('Setup cancelled by user');
+      }
+      return String(response.value);
+    },
+  };
+}

package/src/commands/connect.test.ts

@@ -1,24 +1,18 @@
 /**
  * @license
- * Copyright 2025 Amodal Labs, Inc.
+ * Copyright 2026 Amodal Labs, Inc.
  * SPDX-License-Identifier: MIT
  */
 
 import {describe, it, expect, vi, beforeEach} from 'vitest';
 
 const mockFindRepoRoot = vi.fn(() => '/test/repo');
-const mockEnsureNpmContext = vi.fn();
-const mockNpmInstall = vi.fn();
-const mockAddLockEntry = vi.fn();
-const mockGetLockEntry = vi.fn();
-const mockGetNpmContextPaths = vi.fn();
+const mockEnsurePackageJson = vi.fn();
+const mockPmAdd = vi.fn();
 const mockReadPackageManifest = vi.fn();
 const mockToNpmName = vi.fn((name: string) => `@amodalai/connection-${name}`);
 const mockFindMissingEnvVars = vi.fn();
 const mockUpsertEnvEntries = vi.fn();
-const mockAddConfigDep = vi.fn();
-const mockDiscoverInstalledPackages = vi.fn();
-const mockBuildLockFile = vi.fn();
 
 const mockPromptForCredentials = vi.fn();
 const mockTestConnection = vi.fn();
@@ -26,23 +20,19 @@ const mockRunOAuth2Flow = vi.fn();
 
 const mockPrompts = vi.fn();
 
+const mockStatSync = vi.fn();
+
 vi.mock('../shared/repo-discovery.js', () => ({
   findRepoRoot: mockFindRepoRoot,
 }));
 
 vi.mock('@amodalai/core', () => ({
-  ensureNpmContext: mockEnsureNpmContext,
-  npmInstall: mockNpmInstall,
-  addLockEntry: mockAddLockEntry,
-  getLockEntry: mockGetLockEntry,
-  getNpmContextPaths: mockGetNpmContextPaths,
+  ensurePackageJson: mockEnsurePackageJson,
+  pmAdd: mockPmAdd,
   readPackageManifest: mockReadPackageManifest,
   toNpmName: mockToNpmName,
   findMissingEnvVars: mockFindMissingEnvVars,
   upsertEnvEntries: mockUpsertEnvEntries,
-  addConfigDep: mockAddConfigDep,
-  discoverInstalledPackages: mockDiscoverInstalledPackages,
-  buildLockFile: mockBuildLockFile,
 }));
 
 vi.mock('../auth/index.js', () => ({
@@ -55,13 +45,13 @@ vi.mock('prompts', () => ({
   default: mockPrompts,
 }));
 
-const mockPaths = {
-  root: '/test/repo/.amodal/packages',
-  npmDir: '/test/repo/.amodal/packages/.npm',
-  npmrc: '/test/repo/.amodal/packages/.npm/.npmrc',
-  packageJson: '/test/repo/.amodal/packages/.npm/package.json',
-  nodeModules: '/test/repo/.amodal/packages/.npm/node_modules',
-};
+vi.mock('node:fs', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:fs')>();
+  return {
+    ...actual,
+    statSync: mockStatSync,
+  };
+});
 
 const bearerManifest = {
   name: 'stripe',
@@ -105,16 +95,13 @@ describe('runConnect', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockFindRepoRoot.mockReturnValue('/test/repo');
-    mockEnsureNpmContext.mockResolvedValue(mockPaths);
-    mockGetLockEntry.mockResolvedValue(null); // fresh install by default
-    mockNpmInstall.mockResolvedValue({version: '1.0.0', integrity: 'sha512-abc'});
-    mockAddLockEntry.mockResolvedValue({lockVersion: 2, packages: {}});
-    mockGetNpmContextPaths.mockReturnValue(mockPaths);
+    // By default, package is NOT installed (statSync throws)
+    mockStatSync.mockImplementation(() => {
+      throw new Error('ENOENT');
+    });
+    mockPmAdd.mockResolvedValue(undefined);
     mockFindMissingEnvVars.mockResolvedValue([]);
     mockUpsertEnvEntries.mockResolvedValue(undefined);
-    mockAddConfigDep.mockResolvedValue(undefined);
-    mockDiscoverInstalledPackages.mockResolvedValue([]);
-    mockBuildLockFile.mockResolvedValue(undefined);
     mockPromptForCredentials.mockResolvedValue({credentials: {}, summary: 'Set 1 credential'});
     mockTestConnection.mockResolvedValue({connectionName: 'test', results: [], allPassed: true});
     stderrOutput = '';
@@ -135,7 +122,7 @@ describe('runConnect', () => {
     const {runConnect} = await import('./connect.js');
     const result = await runConnect({name: 'stripe'});
     expect(result).toBe(0);
-    expect(mockNpmInstall).toHaveBeenCalled();
+    expect(mockPmAdd).toHaveBeenCalled();
     expect(mockPromptForCredentials).toHaveBeenCalled();
     expect(mockTestConnection).toHaveBeenCalled();
     expect(stderrOutput).toContain('Connected: stripe');
@@ -147,7 +134,7 @@ describe('runConnect', () => {
     const {runConnect} = await import('./connect.js');
     const result = await runConnect({name: 'datadog'});
     expect(result).toBe(0);
-    expect(mockNpmInstall).toHaveBeenCalled();
+    expect(mockPmAdd).toHaveBeenCalled();
     expect(mockPromptForCredentials).toHaveBeenCalled();
   });
 
@@ -182,18 +169,19 @@ describe('runConnect', () => {
   });
 
   it('should skip install on reconnect', async () => {
-    mockGetLockEntry.mockResolvedValue({version: '1.0.0', integrity: 'sha512-abc'});
+    // Package already installed in node_modules
+    mockStatSync.mockReturnValue({isDirectory: () => true});
     mockReadPackageManifest.mockResolvedValue(bearerManifest);
 
     const {runConnect} = await import('./connect.js');
     const result = await runConnect({name: 'stripe'});
     expect(result).toBe(0);
-    expect(mockNpmInstall).not.toHaveBeenCalled();
+    expect(mockPmAdd).not.toHaveBeenCalled();
     expect(stderrOutput).toContain('already installed');
   });
 
   it('should skip credential prompt on reconnect when vars present', async () => {
-    mockGetLockEntry.mockResolvedValue({version: '1.0.0', integrity: 'sha512-abc'});
+    mockStatSync.mockReturnValue({isDirectory: () => true});
     mockReadPackageManifest.mockResolvedValue(bearerManifest);
     mockFindMissingEnvVars.mockResolvedValue([]);
 
@@ -204,7 +192,7 @@ describe('runConnect', () => {
   });
 
   it('should re-prompt on reconnect with force', async () => {
-    mockGetLockEntry.mockResolvedValue({version: '1.0.0', integrity: 'sha512-abc'});
+    mockStatSync.mockReturnValue({isDirectory: () => true});
     mockReadPackageManifest.mockResolvedValue(bearerManifest);
 
     const {runConnect} = await import('./connect.js');
@@ -239,7 +227,7 @@ describe('runConnect', () => {
   });
 
   it('should return 1 when npm install fails', async () => {
-    mockNpmInstall.mockRejectedValue(new Error('Registry down'));
+    mockPmAdd.mockRejectedValue(new Error('Registry down'));
 
     const {runConnect} = await import('./connect.js');
     const result = await runConnect({name: 'stripe'});
@@ -291,7 +279,7 @@ describe('runConnect', () => {
   });
 
   it('should prompt for missing vars on reconnect without force', async () => {
-    mockGetLockEntry.mockResolvedValue({version: '1.0.0', integrity: 'sha512-abc'});
+    mockStatSync.mockReturnValue({isDirectory: () => true});
     mockReadPackageManifest.mockResolvedValue(bearerManifest);
     mockFindMissingEnvVars.mockResolvedValue(['STRIPE_API_KEY']);
 

package/src/commands/connect.ts

@@ -1,23 +1,18 @@
 /**
  * @license
- * Copyright 2025 Amodal Labs, Inc.
+ * Copyright 2026 Amodal Labs, Inc.
  * SPDX-License-Identifier: MIT
  */
 
+import {statSync} from 'node:fs';
 import {join} from 'node:path';
 
 import type {CommandModule} from 'yargs';
 import prompts from 'prompts';
 import {
-  addConfigDep,
-  addLockEntry,
-  buildLockFile,
-  discoverInstalledPackages,
-  ensureNpmContext,
+  ensurePackageJson,
   findMissingEnvVars,
-  getLockEntry,
-  getNpmContextPaths,
-  npmInstall,
+  pmAdd,
   readPackageManifest,
   toNpmName,
   upsertEnvEntries,
@@ -47,24 +42,23 @@ export async function runConnect(options: ConnectOptions): Promise<number> {
     return 1;
   }
 
-  const paths = await ensureNpmContext(repoPath);
   const npmName = toNpmName(options.name);
-  const existing = await getLockEntry(repoPath, npmName);
-  const isReconnect = existing !== null;
+  const packageDir = join(repoPath, 'node_modules', npmName);
+
+  // Check if already installed by looking in node_modules
+  let isReconnect = false;
+  try {
+    isReconnect = statSync(packageDir).isDirectory();
+  } catch {
+    // Not installed
+  }
 
   // Step 1: Install if fresh
   if (!isReconnect) {
     process.stderr.write(`[connect] Installing ${npmName}...\n`);
     try {
-      const result = await npmInstall(paths, npmName);
-      await addLockEntry(repoPath, npmName, {
-        version: result.version,
-        integrity: result.integrity,
-      });
-      await addConfigDep(repoPath, npmName, result.version);
-      // Rebuild lock file from what's actually installed
-      const discovered = await discoverInstalledPackages(paths);
-      await buildLockFile(repoPath, discovered);
+      ensurePackageJson(repoPath, 'amodal-project');
+      await pmAdd(repoPath, npmName);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`[connect] Install failed: ${msg}\n`);
@@ -75,9 +69,6 @@ export async function runConnect(options: ConnectOptions): Promise<number> {
   }
 
   // Step 2: Read manifest
-  const contextPaths = getNpmContextPaths(repoPath);
-  const packageDir = join(contextPaths.nodeModules, npmName);
-
   let manifest;
   try {
     manifest = await readPackageManifest(packageDir);
@@ -230,3 +221,18 @@ export const connectCommand: CommandModule = {
     process.exit(code);
   },
 };
+
+/** Variant of connectCommand registered as `amodal connect connection <name>`. */
+export const connectConnectionCommand: CommandModule = {
+  command: 'connection <name>',
+  describe: 'Connect a connection package (install + auth + test)',
+  builder: (yargs) =>
+    yargs
+      .positional('name', {type: 'string', demandOption: true, describe: 'Connection name'})
+      .option('force', {type: 'boolean', default: false, describe: 'Force re-authentication'}),
+  handler: async (argv) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    const code = await runConnect({name: argv['name'] as string, force: argv['force'] as boolean});
+    process.exit(code);
+  },
+};

package/src/commands/groups/connect.ts

@@ -0,0 +1,20 @@
+/**
+ * @license
+ * Copyright 2026 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {connectConnectionCommand} from '../connect.js';
+import {connectChannelCommand} from '../connect-channel.js';
+
+export const connectGroupCommand: CommandModule = {
+  command: 'connect <command>',
+  describe: 'Connect a package (connection or channel)',
+  builder: (yargs) =>
+    yargs
+      .command(connectConnectionCommand)
+      .command(connectChannelCommand)
+      .demandCommand(1, 'Specify: connection or channel'),
+  handler: () => {},
+};

package/src/commands/groups/pkg.ts

@@ -5,14 +5,8 @@
  */
 
 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 {linkCommand} from '../link.js';
 import {syncCommand} from '../sync.js';
 
@@ -21,14 +15,8 @@ export const pkgCommand: CommandModule = {
   describe: 'Manage packages',
   builder: (yargs) =>
     yargs
-      .command(connectCommand)
       .command(installPkgCommand)
       .command(uninstallCommand)
-      .command(listCommand)
-      .command(updateCommand)
-      .command(diffCommand)
-      .command(searchCommand)
-      .command(publishCommand)
       .command(linkCommand)
       .command(syncCommand)
       .demandCommand(1, 'Specify a subcommand'),

package/src/commands/index.ts

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: MIT
  */
 
+ 
+
 import {initCommand} from './init.js';
 import {devCommand} from './dev.js';
 import {inspectCommand} from './inspect.js';
@@ -15,12 +17,13 @@ import {pkgCommand} from './groups/pkg.js';
 import {deployGroupCommand} from './groups/deploy.js';
 import {opsCommand} from './groups/ops.js';
 import {authCommand} from './groups/auth.js';
+import {connectGroupCommand} from './groups/connect.js';
 
 /**
  * All amodal subcommands registered on the root yargs instance.
  *
  * Top-level: daily-driver commands (init, dev, chat, validate, inspect, eval, test)
- * Groups: pkg, deploy, ops, auth
+ * Groups: pkg, deploy, ops, auth, connect
  */
 export const amodalCommands = [
   // Top-level
@@ -36,4 +39,5 @@ export const amodalCommands = [
   deployGroupCommand,
   opsCommand,
   authCommand,
+  connectGroupCommand,
 ];

package/src/commands/init.test.ts

@@ -1,6 +1,6 @@
 /**
  * @license
- * Copyright 2025 Amodal Labs, Inc.
+ * Copyright 2026 Amodal Labs, Inc.
  * SPDX-License-Identifier: MIT
  */
 
@@ -36,7 +36,7 @@ describe('runInit', () => {
     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('node_modules/');
     expect(gitignore).toContain('.env');
   });
 

package/src/commands/init.ts

@@ -7,6 +7,7 @@
 import {existsSync, mkdirSync, writeFileSync} from 'node:fs';
 import {join} from 'node:path';
 import type {CommandModule} from 'yargs';
+import {ensurePackageJson} from '@amodalai/core';
 import {generateConfigTemplate} from '../templates/config-template.js';
 
 export interface InitOptions {
@@ -46,10 +47,13 @@ export async function runInit(options: InitOptions = {}): Promise<void> {
   // Write amodal.json at repo root
   writeFileSync(configPath, generateConfigTemplate({name, provider}));
 
+  // Ensure package.json exists
+  ensurePackageJson(cwd, name);
+
   // 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');
+    writeFileSync(gitignorePath, '.amodal/\nnode_modules/\n.env\n.env.*\n');
   }
 
   process.stderr.write(`[init] Created project "${name}" (${provider})\n`);

package/src/commands/inspect.test.ts

@@ -1,13 +1,12 @@
 /**
  * @license
- * Copyright 2025 Amodal Labs, Inc.
+ * Copyright 2026 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', () => ({
@@ -15,7 +14,6 @@ vi.mock('../shared/repo-discovery.js', () => ({
 }));
 
 vi.mock('@amodalai/core', () => ({
-  readLockFile: mockReadLockFile,
   resolveAllPackages: mockResolveAllPackages,
   loadRepo: vi.fn().mockResolvedValue({
     config: {models: {main: {provider: 'anthropic', model: 'test'}}},
@@ -130,7 +128,6 @@ describe('runInspect', () => {
 
   // Resolved package tests
   it('should show resolved packages when resolved flag set', async () => {
-    mockReadLockFile.mockResolvedValue({lockVersion: 2, packages: {}});
     mockResolveAllPackages.mockResolvedValue({
       connections: new Map([['salesforce', {surface: [{}, {}, {}], spec: {auth: {type: 'bearer'}}}]]),
       skills: [{name: 'triage', body: 'Triage methodology content'}],
@@ -149,7 +146,6 @@ describe('runInspect', () => {
   });
 
   it('should filter by scope', async () => {
-    mockReadLockFile.mockResolvedValue({lockVersion: 2, packages: {}});
     mockResolveAllPackages.mockResolvedValue({
       connections: new Map([
         ['salesforce', {surface: [{}, {}], spec: {auth: {type: 'bearer'}}}],
@@ -169,18 +165,7 @@ describe('runInspect', () => {
     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: 2, packages: {}});
     mockResolveAllPackages.mockResolvedValue({
       connections: new Map(),
       skills: [],
@@ -198,7 +183,6 @@ describe('runInspect', () => {
   });
 
   it('should show connection details in resolved view', async () => {
-    mockReadLockFile.mockResolvedValue({lockVersion: 2, packages: {}});
     mockResolveAllPackages.mockResolvedValue({
       connections: new Map([['crm', {surface: [{}, {}], spec: {auth: {type: 'oauth2'}}}]]),
       skills: [],
@@ -216,7 +200,6 @@ describe('runInspect', () => {
   });
 
   it('should show skill body length in resolved view', async () => {
-    mockReadLockFile.mockResolvedValue({lockVersion: 2, packages: {}});
     mockResolveAllPackages.mockResolvedValue({
       connections: new Map(),
       skills: [{name: 'investigate', body: 'A'.repeat(500)}],