@amodalai/amodal 0.1.2

package/src/commands/uninstall.ts

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import {unlink, stat} from 'node:fs/promises';
+import {join} from 'node:path';
+
+import type {CommandModule} from 'yargs';
+import {
+  getLockEntry,
+  getNpmContextPaths,
+  makePackageRef,
+  npmUninstall,
+  removeConfigDep,
+  removeLockEntry,
+  toSymlinkName,
+} from '@amodalai/core';
+import type {PackageType} from '@amodalai/core';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+export interface UninstallOptions {
+  cwd?: string;
+  type: PackageType;
+  name: string;
+}
+
+/**
+ * Uninstall a package: npm uninstall + remove lock entry + remove symlink.
+ * Returns 0 on success, 1 on error.
+ */
+export async function runUninstall(options: UninstallOptions): Promise<number> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[uninstall] ${msg}\n`);
+    return 1;
+  }
+
+  const entry = await getLockEntry(repoPath, options.type, options.name);
+  if (!entry) {
+    process.stderr.write(`[uninstall] ${options.type}/${options.name} is not installed.\n`);
+    return 1;
+  }
+
+  const paths = getNpmContextPaths(repoPath);
+  const ref = makePackageRef(options.type, options.name);
+
+  try {
+    await npmUninstall(paths, ref.npmName);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[uninstall] npm uninstall failed: ${msg}\n`);
+    return 1;
+  }
+
+  await removeLockEntry(repoPath, options.type, options.name);
+
+  // Remove from amodal.json dependencies
+  try {
+    await removeConfigDep(repoPath, options.type, options.name);
+  } catch {
+    // Non-fatal — the dependency may not have been in amodal.json
+  }
+
+  // Remove symlink (ignore if already gone)
+  const symlinkPath = join(paths.root, toSymlinkName(options.type, options.name));
+  try {
+    await unlink(symlinkPath);
+  } catch (err) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+    if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+      process.stderr.write(`[uninstall] Warning: could not remove symlink: ${symlinkPath}\n`);
+    }
+  }
+
+  // Check for repo override directory
+  const overrideDir = join(repoPath, `${options.type}s`, options.name);
+  try {
+    const s = await stat(overrideDir);
+    if (s.isDirectory()) {
+      process.stderr.write(`[uninstall] Note: local override directory still exists: ${overrideDir}\n`);
+    }
+  } catch {
+    // No override dir — nothing to note
+  }
+
+  process.stderr.write(`[uninstall] Removed ${options.type}/${options.name}\n`);
+  return 0;
+}
+
+export const uninstallCommand: CommandModule = {
+  command: 'uninstall <type> <name>',
+  describe: 'Uninstall a package',
+  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 runUninstall({type: argv['type'] as PackageType, name: argv['name'] as string});
+    process.exit(code);
+  },
+};

package/src/commands/update.test.ts

@@ -0,0 +1,281 @@
+/**
+ * @license
+ * Copyright 2025 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 mockReadLockFile = vi.fn();
+const mockNpmViewVersions = vi.fn();
+const mockNpmInstall = vi.fn();
+const mockAddLockEntry = vi.fn();
+const mockEnsureSymlink = vi.fn();
+const mockMakePackageRef = vi.fn((type: string, name: string) => ({
+  type,
+  name,
+  key: `${type}/${name}`,
+  npmName: `@amodalai/${type}-${name}`,
+}));
+const mockParsePackageKey = vi.fn((key: string) => {
+  const [type, name] = key.split('/');
+  return {type, name};
+});
+
+vi.mock('../shared/repo-discovery.js', () => ({
+  findRepoRoot: mockFindRepoRoot,
+}));
+
+vi.mock('@amodalai/core', () => ({
+  ensureNpmContext: mockEnsureNpmContext,
+  readLockFile: mockReadLockFile,
+  npmViewVersions: mockNpmViewVersions,
+  npmInstall: mockNpmInstall,
+  addLockEntry: mockAddLockEntry,
+  ensureSymlink: mockEnsureSymlink,
+  makePackageRef: mockMakePackageRef,
+  parsePackageKey: mockParsePackageKey,
+}));
+
+vi.mock('semver', () => ({
+  maxSatisfying: vi.fn((versions: string[], range: string) => {
+    // Simple mock: return the last version for '*', first matching for '^'
+    if (range === '*') return versions[versions.length - 1];
+    // For ^x.y.z, return last version with same major
+    const major = range.replace('^', '').split('.')[0];
+    const matching = versions.filter((v) => v.startsWith(major + '.'));
+    return matching.length > 0 ? matching[matching.length - 1] : null;
+  }),
+}));
+
+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('runUpdate', () => {
+  let stderrOutput: string;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockFindRepoRoot.mockReturnValue('/test/repo');
+    mockEnsureNpmContext.mockResolvedValue(mockPaths);
+    mockNpmInstall.mockResolvedValue({version: '2.0.0', integrity: 'sha512-new'});
+    mockAddLockEntry.mockResolvedValue({lockVersion: 1, packages: {}});
+    mockEnsureSymlink.mockResolvedValue('/test/repo/.amodal/packages/connection--salesforce');
+    stderrOutput = '';
+    vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => {
+      stderrOutput += String(chunk);
+      return true;
+    });
+  });
+
+  it('should update all packages', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions.mockResolvedValue(['1.0.0', '1.1.0', '1.2.0']);
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate();
+    expect(result).toBe(0);
+    expect(mockNpmInstall).toHaveBeenCalled();
+    expect(stderrOutput).toContain('Updated');
+  });
+
+  it('should update single package by type and name', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+        'skill/triage': {version: '1.0.0', npm: '@amodalai/skill-triage', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions.mockResolvedValue(['1.0.0', '1.1.0']);
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate({type: 'connection', name: 'salesforce'});
+    expect(result).toBe(0);
+    expect(mockNpmViewVersions).toHaveBeenCalledTimes(1);
+  });
+
+  it('should report already up to date', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.2.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions.mockResolvedValue(['1.0.0', '1.1.0', '1.2.0']);
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate();
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('up to date');
+    expect(mockNpmInstall).not.toHaveBeenCalled();
+  });
+
+  it('should show dry run output', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions.mockResolvedValue(['1.0.0', '1.1.0']);
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate({dryRun: true});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('Dry run');
+    expect(stderrOutput).toContain('1.1.0');
+    expect(mockNpmInstall).not.toHaveBeenCalled();
+  });
+
+  it('should use latest flag for cross-major updates', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions.mockResolvedValue(['1.0.0', '1.1.0', '2.0.0', '3.0.0']);
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate({latest: true});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('3.0.0');
+  });
+
+  it('should return 1 when no lock file', async () => {
+    mockReadLockFile.mockResolvedValue(null);
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('No lock file');
+  });
+
+  it('should return 1 when repo not found', async () => {
+    mockFindRepoRoot.mockImplementation(() => {
+      throw new Error('Not found');
+    });
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Not found');
+  });
+
+  it('should handle registry unreachable', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions.mockRejectedValue(new Error('Registry unreachable'));
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('Failed to check');
+  });
+
+  it('should continue on partial failure', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+        'skill/triage': {version: '1.0.0', npm: '@amodalai/skill-triage', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions
+      .mockResolvedValueOnce(['1.0.0', '1.1.0'])
+      .mockResolvedValueOnce(['1.0.0', '1.1.0']);
+    mockNpmInstall
+      .mockRejectedValueOnce(new Error('Install failed'))
+      .mockResolvedValueOnce({version: '1.1.0', integrity: 'sha512-new'});
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate();
+    expect(result).toBe(1);
+    expect(stderrOutput).toContain('1 of 2');
+  });
+
+  it('should handle empty lock file', async () => {
+    mockReadLockFile.mockResolvedValue({lockVersion: 1, packages: {}});
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate();
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('No packages installed');
+  });
+
+  it('should filter by type only', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+        'skill/triage': {version: '1.0.0', npm: '@amodalai/skill-triage', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions.mockResolvedValue(['1.0.0', '1.1.0']);
+
+    const {runUpdate} = await import('./update.js');
+    await runUpdate({type: 'skill'});
+    expect(mockNpmViewVersions).toHaveBeenCalledTimes(1);
+  });
+
+  it('should report no matching packages', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+      },
+    });
+
+    const {runUpdate} = await import('./update.js');
+    const result = await runUpdate({type: 'skill', name: 'nonexistent'});
+    expect(result).toBe(0);
+    expect(stderrOutput).toContain('No matching packages');
+  });
+
+  it('should update lock entry and symlink', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions.mockResolvedValue(['1.0.0', '1.1.0']);
+
+    const {runUpdate} = await import('./update.js');
+    await runUpdate();
+    expect(mockAddLockEntry).toHaveBeenCalled();
+    expect(mockEnsureSymlink).toHaveBeenCalled();
+  });
+
+  it('should use singular form for 1 package', async () => {
+    mockReadLockFile.mockResolvedValue({
+      lockVersion: 1,
+      packages: {
+        'connection/salesforce': {version: '1.0.0', npm: '@amodalai/connection-salesforce', integrity: 'sha512-old'},
+      },
+    });
+    mockNpmViewVersions.mockResolvedValue(['1.0.0', '1.1.0']);
+
+    const {runUpdate} = await import('./update.js');
+    await runUpdate();
+    expect(stderrOutput).toContain('1 package updated');
+    expect(stderrOutput).not.toContain('1 packages');
+  });
+});

package/src/commands/update.ts

@@ -0,0 +1,180 @@
+/**
+ * @license
+ * Copyright 2025 Amodal Labs, Inc.
+ * SPDX-License-Identifier: MIT
+ */
+
+import type {CommandModule} from 'yargs';
+import {
+  addLockEntry,
+  ensureNpmContext,
+  ensureSymlink,
+  makePackageRef,
+  npmInstall,
+  npmViewVersions,
+  parsePackageKey,
+  readLockFile,
+} from '@amodalai/core';
+import type {PackageType} from '@amodalai/core';
+import * as semver from 'semver';
+import {findRepoRoot} from '../shared/repo-discovery.js';
+
+export interface UpdateOptions {
+  cwd?: string;
+  type?: PackageType;
+  name?: string;
+  latest?: boolean;
+  dryRun?: boolean;
+}
+
+interface UpdateTarget {
+  type: PackageType;
+  name: string;
+  currentVersion: string;
+  npmName: string;
+}
+
+/**
+ * Update installed packages to newer versions.
+ * Returns the number of failures (0 = success).
+ */
+export async function runUpdate(options: UpdateOptions = {}): Promise<number> {
+  let repoPath: string;
+  try {
+    repoPath = findRepoRoot(options.cwd);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[update] ${msg}\n`);
+    return 1;
+  }
+
+  const paths = await ensureNpmContext(repoPath);
+
+  const lockFile = await readLockFile(repoPath);
+  if (!lockFile) {
+    process.stderr.write('[update] No lock file found. Install packages first.\n');
+    return 1;
+  }
+
+  // Build list of targets
+  const targets: UpdateTarget[] = [];
+  for (const [key, entry] of Object.entries(lockFile.packages)) {
+    const parsed = parsePackageKey(key);
+    if (options.type && parsed.type !== options.type) continue;
+    if (options.name && parsed.name !== options.name) continue;
+    targets.push({
+      type: parsed.type,
+      name: parsed.name,
+      currentVersion: entry.version,
+      npmName: entry.npm,
+    });
+  }
+
+  if (targets.length === 0) {
+    if (options.type || options.name) {
+      process.stderr.write('[update] No matching packages found in lock file.\n');
+    } else {
+      process.stderr.write('[update] No packages installed.\n');
+    }
+    return 0;
+  }
+
+  // Check for updates
+  const updates: Array<{target: UpdateTarget; newVersion: string}> = [];
+  let failures = 0;
+
+  for (const target of targets) {
+    try {
+      const versions = await npmViewVersions(paths, target.npmName);
+
+      let newVersion: string | null;
+      if (options.latest) {
+        // Take the absolute latest
+        newVersion = semver.maxSatisfying(versions, '*');
+      } else {
+        // Stay within current major (^current)
+        newVersion = semver.maxSatisfying(versions, `^${target.currentVersion}`);
+      }
+
+      if (!newVersion || newVersion === target.currentVersion) {
+        process.stderr.write(`[update] ${target.npmName}@${target.currentVersion} is already up to date.\n`);
+        continue;
+      }
+
+      updates.push({target, newVersion});
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[update] Failed to check ${target.npmName}: ${msg}\n`);
+      failures++;
+    }
+  }
+
+  if (updates.length === 0) {
+    if (failures === 0) {
+      process.stderr.write('[update] All packages are up to date.\n');
+    }
+    return failures;
+  }
+
+  // Print what will be updated
+  if (options.dryRun) {
+    process.stderr.write('[update] Dry run — the following would be updated:\n');
+    for (const {target, newVersion} of updates) {
+      process.stderr.write(`  ${target.npmName}: ${target.currentVersion} → ${newVersion}\n`);
+    }
+    return 0;
+  }
+
+  // Perform updates
+  for (const {target, newVersion} of updates) {
+    process.stderr.write(`[update] Updating ${target.npmName}: ${target.currentVersion} → ${newVersion}...\n`);
+    try {
+      const ref = makePackageRef(target.type, target.name);
+      const result = await npmInstall(paths, target.npmName, newVersion);
+      await addLockEntry(repoPath, target.type, target.name, {
+        version: result.version,
+        npm: target.npmName,
+        integrity: result.integrity,
+      });
+      await ensureSymlink(paths, ref);
+      process.stderr.write(`[update] Updated ${target.npmName}@${result.version}\n`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[update] Failed to update ${target.npmName}: ${msg}\n`);
+      failures++;
+    }
+  }
+
+  const successCount = updates.length - failures;
+  if (failures > 0) {
+    process.stderr.write(`[update] ${failures} of ${updates.length} update${updates.length === 1 ? '' : 's'} failed.\n`);
+  } else {
+    process.stderr.write(`[update] ${successCount} package${successCount === 1 ? '' : 's'} updated.\n`);
+  }
+
+  return failures;
+}
+
+export const updateCommand: CommandModule = {
+  command: 'update [type] [name]',
+  describe: 'Update installed packages',
+  builder: (yargs) =>
+    yargs
+      .positional('type', {type: 'string', choices: ['connection', 'skill', 'automation', 'knowledge'] as const, describe: 'Package type'})
+      .positional('name', {type: 'string', describe: 'Package name'})
+      .option('latest', {type: 'boolean', default: false, describe: 'Allow major version updates'})
+      .option('dry-run', {type: 'boolean', default: false, describe: 'Show what would be updated'}),
+  handler: async (argv) => {
+    const code = await runUpdate({
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      type: argv['type'] as PackageType | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      name: argv['name'] as string | undefined,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      latest: argv['latest'] as boolean,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+      dryRun: argv['dryRun'] as boolean,
+    });
+    process.exit(code);
+  },
+};