@amodalai/amodal 0.2.1 → 0.2.2

package/src/commands/inspect.ts

@@ -5,7 +5,7 @@
  */
 
 import type {CommandModule} from 'yargs';
-import {loadRepo, setupSession, readLockFile, resolveAllPackages} from '@amodalai/core';
+import {loadRepo, setupSession, resolveAllPackages} from '@amodalai/core';
 import {findRepoRoot} from '../shared/repo-discovery.js';
 
 export interface InspectOptions {
@@ -79,47 +79,42 @@ export async function runInspect(options: InspectOptions = {}): Promise<void> {
   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`);
-        }
+    const resolved = await resolveAllPackages({repoPath});
+
+    // 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 === '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`);
-        }
+    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`);
-        }
+    // Print warnings
+    if (resolved.warnings.length > 0) {
+      process.stdout.write('\n  Warnings:\n');
+      for (const warning of resolved.warnings) {
+        process.stdout.write(`    - ${warning}\n`);
       }
     }
   }

package/src/commands/install-pkg.test.ts

@@ -1,43 +1,35 @@
 /**
  * @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 mockReadLockFile = vi.fn();
-const mockReadConfigDeps = vi.fn();
+const mockEnsurePackageJson = vi.fn();
+const mockPmAdd = vi.fn();
+const mockPmInstall = vi.fn();
+const mockAddAmodalPackage = vi.fn();
 const mockToNpmName = vi.fn((name: string) => `@amodalai/${name}`);
-const mockAddConfigDep = vi.fn();
-const mockDiscoverInstalledPackages = vi.fn();
-const mockBuildLockFile = vi.fn();
+
+const mockReadFileSync = vi.fn();
 
 vi.mock('../shared/repo-discovery.js', () => ({
   findRepoRoot: mockFindRepoRoot,
 }));
 
 vi.mock('@amodalai/core', () => ({
-  ensureNpmContext: mockEnsureNpmContext,
-  npmInstall: mockNpmInstall,
-  readLockFile: mockReadLockFile,
-  readConfigDeps: mockReadConfigDeps,
+  ensurePackageJson: mockEnsurePackageJson,
+  pmAdd: mockPmAdd,
+  pmInstall: mockPmInstall,
+  addAmodalPackage: mockAddAmodalPackage,
   toNpmName: mockToNpmName,
-  addConfigDep: mockAddConfigDep,
-  discoverInstalledPackages: mockDiscoverInstalledPackages,
-  buildLockFile: mockBuildLockFile,
 }));
 
-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', () => ({
+  readFileSync: mockReadFileSync,
+}));
 
 describe('runInstallPkg', () => {
   let stderrOutput: string;
@@ -45,11 +37,9 @@ describe('runInstallPkg', () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mockFindRepoRoot.mockReturnValue('/test/repo');
-    mockEnsureNpmContext.mockResolvedValue(mockPaths);
-    mockNpmInstall.mockResolvedValue({version: '1.0.0', integrity: 'sha512-abc'});
-    mockDiscoverInstalledPackages.mockResolvedValue([]);
-    mockBuildLockFile.mockResolvedValue(undefined);
-    mockAddConfigDep.mockResolvedValue(undefined);
+    mockPmAdd.mockResolvedValue(undefined);
+    mockPmInstall.mockResolvedValue(undefined);
+    mockReadFileSync.mockReturnValue(JSON.stringify({name: 'test-project'}));
     stderrOutput = '';
     vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
       stderrOutput += String(chunk);
@@ -57,66 +47,48 @@ describe('runInstallPkg', () => {
     });
   });
 
-  it('should restore from lock file on bare install', async () => {
-    mockReadLockFile.mockResolvedValue({
-      lockVersion: 2,
-      packages: {'@amodalai/connection-salesforce': {version: '2.0.0', integrity: 'sha512-x'}},
-    });
-
+  it('should run pmInstall on bare install', async () => {
     const {runInstallPkg} = await import('./install-pkg.js');
     const result = await runInstallPkg();
     expect(result).toBe(0);
-    expect(mockNpmInstall).toHaveBeenCalledWith(mockPaths, '@amodalai/connection-salesforce', '2.0.0');
-    expect(stderrOutput).toContain('Restoring 1 package');
+    expect(mockEnsurePackageJson).toHaveBeenCalledWith('/test/repo', 'test-project');
+    expect(mockPmInstall).toHaveBeenCalledWith('/test/repo');
+    expect(stderrOutput).toContain('Done');
   });
 
-  it('should print nothing to install when no lock file and no deps on bare install', async () => {
-    mockReadLockFile.mockResolvedValue(null);
-    mockReadConfigDeps.mockResolvedValue({});
+  it('should handle pmInstall failure on bare install', async () => {
+    mockPmInstall.mockRejectedValue(new Error('Install failed'));
 
     const {runInstallPkg} = await import('./install-pkg.js');
     const result = await runInstallPkg();
-    expect(result).toBe(0);
-    expect(stderrOutput).toContain('Nothing to install');
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Install failed');
   });
 
   it('should install a single package', async () => {
-    mockDiscoverInstalledPackages.mockResolvedValue([
-      {npmName: '@amodalai/alert-enrichment', version: '1.0.0', integrity: 'sha512-abc'},
-    ]);
-
     const {runInstallPkg} = await import('./install-pkg.js');
     const result = await runInstallPkg({
       packages: ['alert-enrichment'],
     });
     expect(result).toBe(0);
     expect(mockToNpmName).toHaveBeenCalledWith('alert-enrichment');
-    expect(mockNpmInstall).toHaveBeenCalledWith(mockPaths, '@amodalai/alert-enrichment');
-    expect(mockDiscoverInstalledPackages).toHaveBeenCalledWith(mockPaths);
-    expect(mockBuildLockFile).toHaveBeenCalledWith('/test/repo', expect.any(Array));
+    expect(mockPmAdd).toHaveBeenCalledWith('/test/repo', '@amodalai/alert-enrichment');
+    expect(mockAddAmodalPackage).toHaveBeenCalledWith('/test/repo', '@amodalai/alert-enrichment');
   });
 
   it('should install multiple packages', async () => {
-    mockDiscoverInstalledPackages.mockResolvedValue([
-      {npmName: '@amodalai/connection-stripe', version: '1.0.0', integrity: 'sha512-abc'},
-      {npmName: '@amodalai/soc-agent', version: '1.0.0', integrity: 'sha512-def'},
-    ]);
-
     const {runInstallPkg} = await import('./install-pkg.js');
     const result = await runInstallPkg({
       packages: ['connection-stripe', 'soc-agent'],
     });
     expect(result).toBe(0);
-    expect(mockNpmInstall).toHaveBeenCalledTimes(2);
+    expect(mockPmAdd).toHaveBeenCalledTimes(2);
   });
 
   it('should continue on error and report failure count', async () => {
-    mockNpmInstall
+    mockPmAdd
       .mockRejectedValueOnce(new Error('Network error'))
-      .mockResolvedValueOnce({version: '1.0.0', integrity: 'sha512-ok'});
-    mockDiscoverInstalledPackages.mockResolvedValue([
-      {npmName: '@amodalai/good', version: '1.0.0', integrity: 'sha512-ok'},
-    ]);
+      .mockResolvedValueOnce(undefined);
 
     const {runInstallPkg} = await import('./install-pkg.js');
     const result = await runInstallPkg({
@@ -128,10 +100,9 @@ describe('runInstallPkg', () => {
   });
 
   it('should report all failures', async () => {
-    mockNpmInstall
+    mockPmAdd
       .mockRejectedValueOnce(new Error('Fail 1'))
       .mockRejectedValueOnce(new Error('Fail 2'));
-    mockDiscoverInstalledPackages.mockResolvedValue([]);
 
     const {runInstallPkg} = await import('./install-pkg.js');
     const result = await runInstallPkg({
@@ -152,27 +123,25 @@ describe('runInstallPkg', () => {
     expect(stderrOutput).toContain('Not found');
   });
 
-  it('should handle bare install with empty lock file packages', async () => {
-    mockReadLockFile.mockResolvedValue({lockVersion: 2, packages: {}});
+  it('should use default project name when amodal.json is missing', async () => {
+    mockReadFileSync.mockImplementation(() => {
+      throw new Error('ENOENT');
+    });
 
     const {runInstallPkg} = await import('./install-pkg.js');
     const result = await runInstallPkg();
     expect(result).toBe(0);
-    expect(stderrOutput).toContain('Nothing to install');
+    expect(mockEnsurePackageJson).toHaveBeenCalledWith('/test/repo', 'amodal-project');
   });
 
   it('should pass cwd to findRepoRoot', async () => {
-    mockReadLockFile.mockResolvedValue(null);
-    mockReadConfigDeps.mockResolvedValue({});
-
     const {runInstallPkg} = await import('./install-pkg.js');
     await runInstallPkg({cwd: '/custom/dir'});
     expect(mockFindRepoRoot).toHaveBeenCalledWith('/custom/dir');
   });
 
-  it('should handle npm install failure for single package', async () => {
-    mockNpmInstall.mockRejectedValue(new Error('Registry unreachable'));
-    mockDiscoverInstalledPackages.mockResolvedValue([]);
+  it('should handle npm add failure for single package', async () => {
+    mockPmAdd.mockRejectedValue(new Error('Registry unreachable'));
 
     const {runInstallPkg} = await import('./install-pkg.js');
     const result = await runInstallPkg({
@@ -183,12 +152,9 @@ describe('runInstallPkg', () => {
   });
 
   it('should handle empty packages array like bare install', async () => {
-    mockReadLockFile.mockResolvedValue(null);
-    mockReadConfigDeps.mockResolvedValue({});
-
     const {runInstallPkg} = await import('./install-pkg.js');
     const result = await runInstallPkg({packages: []});
     expect(result).toBe(0);
-    expect(stderrOutput).toContain('Nothing to install');
+    expect(mockPmInstall).toHaveBeenCalledWith('/test/repo');
   });
 });

package/src/commands/install-pkg.ts

@@ -1,30 +1,29 @@
 /**
  * @license
- * Copyright 2025 Amodal Labs, Inc.
+ * Copyright 2026 Amodal Labs, Inc.
  * SPDX-License-Identifier: MIT
  */
 
+import {readFileSync} from 'node:fs';
+import * as path from 'node:path';
 import type {CommandModule} from 'yargs';
 import {
-  addConfigDep,
-  buildLockFile,
-  discoverInstalledPackages,
-  ensureNpmContext,
-  npmInstall,
-  readConfigDeps,
-  readLockFile,
+  ensurePackageJson,
+  addAmodalPackage,
+  pmAdd,
+  pmInstall,
   toNpmName,
 } from '@amodalai/core';
 import {findRepoRoot} from '../shared/repo-discovery.js';
 
 /**
- * Install one or more packages, or restore all from lock file.
+ * Install one or more packages, or run a bare install.
  * Returns the number of failures (0 = success).
  *
  * Usage:
- *   amodal install                          — restore from lock file or amodal.json deps
- *   amodal install alert-enrichment         — install @amodalai/alert-enrichment + transitive deps
- *   amodal install @amodalai/soc-agent      — install with full npm name
+ *   amodal install                          — run package manager install
+ *   amodal install alert-enrichment         — add @amodalai/alert-enrichment
+ *   amodal install @amodalai/soc-agent      — add with full npm name
  */
 export async function runInstallPkg(options: {cwd?: string; packages?: string[]} = {}): Promise<number> {
   let repoPath: string;
@@ -36,74 +35,43 @@ export async function runInstallPkg(options: {cwd?: string; packages?: string[]}
     return 1;
   }
 
-  const paths = await ensureNpmContext(repoPath);
-
-  // Bare install: restore from lock file or amodal.json dependencies
-  if (!options.packages || options.packages.length === 0) {
-    const lockFile = await readLockFile(repoPath);
-
-    if (lockFile && Object.keys(lockFile.packages).length > 0) {
-      const entries = Object.entries(lockFile.packages);
-      process.stderr.write(`[install] Restoring ${entries.length} package(s) from lock file...\n`);
-      let failures = 0;
-      for (const [npmName, entry] of entries) {
-        try {
-          await npmInstall(paths, npmName, entry.version);
-        } catch (err) {
-          const msg = err instanceof Error ? err.message : String(err);
-          process.stderr.write(`[install] Failed: ${npmName}@${entry.version}: ${msg}\n`);
-          failures++;
-        }
-      }
-      if (failures > 0) {
-        process.stderr.write(`[install] ${failures} package(s) failed.\n`);
-        return failures;
-      }
-      process.stderr.write(`[install] Restored ${entries.length} package(s).\n`);
-      return 0;
+  // Read project name from amodal.json for ensurePackageJson
+  let projectName = 'amodal-project';
+  try {
+    const configRaw = readFileSync(path.join(repoPath, 'amodal.json'), 'utf-8');
+    const config: unknown = JSON.parse(configRaw);
+    if (config && typeof config === 'object' && 'name' in config) {
+      projectName = String((config as Record<string, unknown>)['name']);
     }
+  } catch {
+    // Use default project name
+  }
 
-    // No lock file — check amodal.json dependencies
-    let deps: Record<string, string>;
-    try {
-      deps = await readConfigDeps(repoPath);
-    } catch {
-      deps = {};
-    }
+  ensurePackageJson(repoPath, projectName);
 
-    if (Object.keys(deps).length === 0) {
-      process.stderr.write('[install] Nothing to install.\n');
+  // Bare install: run package manager install
+  if (!options.packages || options.packages.length === 0) {
+    process.stderr.write('[install] Running package manager install...\n');
+    try {
+      await pmInstall(repoPath);
+      process.stderr.write('[install] Done.\n');
       return 0;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[install] Install failed: ${msg}\n`);
+      return 1;
     }
-
-    process.stderr.write(`[install] Installing ${Object.keys(deps).length} package(s) from amodal.json...\n`);
-    let failures = 0;
-    for (const [name, versionRange] of Object.entries(deps)) {
-      const npmName = toNpmName(name);
-      try {
-        await npmInstall(paths, npmName, versionRange);
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`[install] Failed: ${npmName}@${versionRange}: ${msg}\n`);
-        failures++;
-      }
-    }
-
-    // Rebuild lock file from what's actually installed
-    const discovered = await discoverInstalledPackages(paths);
-    await buildLockFile(repoPath, discovered);
-    process.stderr.write(`[install] ${discovered.length} package(s) installed.\n`);
-    return failures;
   }
 
   // Install specific packages
   let failures = 0;
   for (const name of options.packages) {
     const npmName = toNpmName(name);
-    process.stderr.write(`[install] Installing ${npmName}...\n`);
+    process.stderr.write(`[install] Adding ${npmName}...\n`);
     try {
-      await npmInstall(paths, npmName);
-      process.stderr.write(`[install] Installed ${npmName}\n`);
+      await pmAdd(repoPath, npmName);
+      addAmodalPackage(repoPath, npmName);
+      process.stderr.write(`[install] Added ${npmName}\n`);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`[install] Failed: ${npmName}: ${msg}\n`);
@@ -111,27 +79,10 @@ export async function runInstallPkg(options: {cwd?: string; packages?: string[]}
     }
   }
 
-  // Discover everything installed (including transitive deps) and rebuild lock file
-  const discovered = await discoverInstalledPackages(paths);
-  await buildLockFile(repoPath, discovered);
-
-  // Add direct installs to amodal.json dependencies
-  for (const name of options.packages) {
-    const npmName = toNpmName(name);
-    const installed = discovered.find((d) => d.npmName === npmName);
-    if (installed) {
-      try {
-        await addConfigDep(repoPath, npmName, installed.version);
-      } catch {
-        // amodal.json might not exist yet
-      }
-    }
-  }
-
   if (failures > 0) {
     process.stderr.write(`[install] ${failures} package(s) failed.\n`);
   } else {
-    process.stderr.write(`[install] ${discovered.length} total package(s) (including dependencies).\n`);
+    process.stderr.write(`[install] ${options.packages.length} package(s) added.\n`);
   }
 
   return failures;
@@ -139,7 +90,7 @@ export async function runInstallPkg(options: {cwd?: string; packages?: string[]}
 
 export const installPkgCommand: CommandModule = {
   command: 'install [packages..]',
-  describe: 'Install packages (or restore all from lock file)',
+  describe: 'Install packages (or run bare install)',
   builder: (yargs) =>
     yargs.positional('packages', {type: 'string', array: true, describe: 'Package names to install'}),
   handler: async (argv) => {

package/src/commands/uninstall.test.ts

@@ -1,60 +1,33 @@
 /**
  * @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 mockGetNpmContextPaths = vi.fn();
 const mockToNpmName = vi.fn((name: string) => `@amodalai/${name}`);
-const mockNpmUninstall = vi.fn();
-const mockEnsureNpmContext = vi.fn();
-const mockDiscoverInstalledPackages = vi.fn();
-const mockBuildLockFile = vi.fn();
-
-const mockReadFile = vi.fn();
-const mockWriteFile = vi.fn();
+const mockPmRemove = vi.fn();
+const mockRemoveAmodalPackage = vi.fn();
 
 vi.mock('../shared/repo-discovery.js', () => ({
   findRepoRoot: mockFindRepoRoot,
 }));
 
 vi.mock('@amodalai/core', () => ({
-  getNpmContextPaths: mockGetNpmContextPaths,
   toNpmName: mockToNpmName,
-  npmUninstall: mockNpmUninstall,
-  ensureNpmContext: mockEnsureNpmContext,
-  discoverInstalledPackages: mockDiscoverInstalledPackages,
-  buildLockFile: mockBuildLockFile,
-}));
-
-vi.mock('node:fs/promises', () => ({
-  readFile: mockReadFile,
-  writeFile: mockWriteFile,
+  pmRemove: mockPmRemove,
+  removeAmodalPackage: mockRemoveAmodalPackage,
 }));
 
-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',
-};
-
 describe('runUninstall', () => {
   let stderrOutput: string;
 
   beforeEach(() => {
     vi.clearAllMocks();
     mockFindRepoRoot.mockReturnValue('/test/repo');
-    mockGetNpmContextPaths.mockReturnValue(mockPaths);
-    mockNpmUninstall.mockResolvedValue(undefined);
-    mockEnsureNpmContext.mockResolvedValue(mockPaths);
-    mockDiscoverInstalledPackages.mockResolvedValue([]);
-    mockBuildLockFile.mockResolvedValue(undefined);
-    mockReadFile.mockRejectedValue(new Error('ENOENT')); // amodal.json not found by default
+    mockPmRemove.mockResolvedValue(undefined);
     stderrOutput = '';
     vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
       stderrOutput += String(chunk);
@@ -66,19 +39,18 @@ describe('runUninstall', () => {
     const {runUninstall} = await import('./uninstall.js');
     const result = await runUninstall({name: 'connection-stripe'});
     expect(result).toBe(0);
-    expect(mockNpmUninstall).toHaveBeenCalledWith(mockPaths, '@amodalai/connection-stripe');
-    expect(mockDiscoverInstalledPackages).toHaveBeenCalledWith(mockPaths);
-    expect(mockBuildLockFile).toHaveBeenCalledWith('/test/repo', []);
+    expect(mockPmRemove).toHaveBeenCalledWith('/test/repo', '@amodalai/connection-stripe');
+    expect(mockRemoveAmodalPackage).toHaveBeenCalledWith('/test/repo', '@amodalai/connection-stripe');
     expect(stderrOutput).toContain('Removed @amodalai/connection-stripe');
   });
 
-  it('should return 1 when npm uninstall fails', async () => {
-    mockNpmUninstall.mockRejectedValue(new Error('npm error'));
+  it('should return 1 when pm remove fails', async () => {
+    mockPmRemove.mockRejectedValue(new Error('npm error'));
 
     const {runUninstall} = await import('./uninstall.js');
     const result = await runUninstall({name: 'skill-triage'});
     expect(result).toBe(1);
-    expect(stderrOutput).toContain('npm uninstall failed');
+    expect(stderrOutput).toContain('Failed to remove');
   });
 
   it('should return 1 when repo not found', async () => {
@@ -97,16 +69,4 @@ describe('runUninstall', () => {
     await runUninstall({cwd: '/custom/dir', name: 'connection-test'});
     expect(mockFindRepoRoot).toHaveBeenCalledWith('/custom/dir');
   });
-
-  it('should remove dependency from amodal.json when it exists', async () => {
-    mockReadFile.mockResolvedValue(JSON.stringify({
-      name: 'test',
-      dependencies: {'@amodalai/connection-stripe': '1.0.0', '@amodalai/soc-agent': '2.0.0'},
-    }));
-
-    const {runUninstall} = await import('./uninstall.js');
-    const result = await runUninstall({name: 'connection-stripe'});
-    expect(result).toBe(0);
-    expect(mockWriteFile).toHaveBeenCalled();
-  });
 });

package/src/commands/uninstall.ts

@@ -1,24 +1,19 @@
 /**
  * @license
- * Copyright 2025 Amodal Labs, Inc.
+ * Copyright 2026 Amodal Labs, Inc.
  * SPDX-License-Identifier: MIT
  */
 
-import {readFile, writeFile} from 'node:fs/promises';
-import * as path from 'node:path';
 import type {CommandModule} from 'yargs';
 import {
-  buildLockFile,
-  discoverInstalledPackages,
-  ensureNpmContext,
-  getNpmContextPaths,
-  npmUninstall,
+  pmRemove,
+  removeAmodalPackage,
   toNpmName,
 } from '@amodalai/core';
 import {findRepoRoot} from '../shared/repo-discovery.js';
 
 /**
- * Uninstall a package: npm uninstall + rebuild lock file.
+ * Uninstall a package via the detected package manager.
  * Returns 0 on success, 1 on error.
  */
 export async function runUninstall(options: {cwd?: string; name: string}): Promise<number> {
@@ -32,40 +27,16 @@ export async function runUninstall(options: {cwd?: string; name: string}): Promi
   }
 
   const npmName = toNpmName(options.name);
-  const paths = getNpmContextPaths(repoPath);
 
   try {
-    await npmUninstall(paths, npmName);
+    await pmRemove(repoPath, npmName);
+    removeAmodalPackage(repoPath, npmName);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`[uninstall] npm uninstall failed: ${msg}\n`);
+    process.stderr.write(`[uninstall] Failed to remove ${npmName}: ${msg}\n`);
     return 1;
   }
 
-  // Rebuild lock file from remaining packages
-  await ensureNpmContext(repoPath);
-  const discovered = await discoverInstalledPackages(paths);
-  await buildLockFile(repoPath, discovered);
-
-  // Remove from amodal.json dependencies
-  try {
-    const configPath = path.join(repoPath, 'amodal.json');
-    const configRaw = await readFile(configPath, 'utf-8');
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- config JSON
-    const config = JSON.parse(configRaw) as Record<string, unknown>;
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
-    const deps = (config['dependencies'] as Record<string, string>) ?? {};
-    delete deps[npmName];
-    if (Object.keys(deps).length > 0) {
-      config['dependencies'] = deps;
-    } else {
-      delete config['dependencies'];
-    }
-    await writeFile(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-  } catch {
-    // Non-fatal
-  }
-
   process.stderr.write(`[uninstall] Removed ${npmName}\n`);
   return 0;
 }