@dot-ai/core 0.10.0 → 0.11.1

package/src/__tests__/package-manager.test.ts

@@ -0,0 +1,237 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdir, writeFile, rm, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import {
+  listPackages,
+  resolvePackages,
+  ensurePackagesInstalled,
+} from '../package-manager.js';
+
+// Use temp directory for test fixtures
+const testDir = join(tmpdir(), 'dot-ai-pkg-test-' + Date.now());
+
+beforeEach(async () => {
+  await mkdir(join(testDir, '.ai', 'packages'), { recursive: true });
+});
+
+afterEach(async () => {
+  await rm(testDir, { recursive: true, force: true });
+});
+
+// ── Helper: create a fake installed package ─────────────────────────────────
+async function createFakePackage(
+  name: string,
+  version: string,
+  dotAi?: { extensions?: string[] },
+) {
+  const installDir = join(testDir, '.ai', 'packages');
+  const pkgDir = join(installDir, 'node_modules', name);
+  await mkdir(pkgDir, { recursive: true });
+
+  // Write package.json for installed package
+  const pkgJson: Record<string, unknown> = { name, version };
+  if (dotAi) pkgJson['dot-ai'] = dotAi;
+  await writeFile(join(pkgDir, 'package.json'), JSON.stringify(pkgJson));
+
+  // Create extension files if declared
+  if (dotAi?.extensions) {
+    for (const ext of dotAi.extensions) {
+      const extPath = join(pkgDir, ext);
+      await mkdir(join(extPath, '..'), { recursive: true });
+      await writeFile(extPath, 'export default function() {}');
+    }
+  }
+
+  // Update the packages/package.json dependencies
+  const depsPkgPath = join(installDir, 'package.json');
+  let deps: Record<string, string> = {};
+  try {
+    const raw = await readFile(depsPkgPath, 'utf-8');
+    const existing = JSON.parse(raw);
+    deps = existing.dependencies ?? {};
+  } catch { /* no file yet */ }
+
+  deps[name] = version;
+  await writeFile(depsPkgPath, JSON.stringify({ dependencies: deps }));
+}
+
+describe('listPackages', () => {
+  it('returns empty array when no packages installed', async () => {
+    const result = await listPackages(testDir);
+    expect(result).toEqual([]);
+  });
+
+  it('lists installed packages with dot-ai field', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await listPackages(testDir);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('@dot-ai/ext-memory');
+    expect(result[0].version).toBe('1.0.0');
+    expect(result[0].dotAi?.extensions).toEqual(['./dist/extension.js']);
+  });
+
+  it('lists packages without dot-ai field', async () => {
+    await createFakePackage('some-lib', '2.0.0');
+
+    const result = await listPackages(testDir);
+    expect(result).toHaveLength(1);
+    expect(result[0].name).toBe('some-lib');
+    expect(result[0].dotAi).toBeUndefined();
+  });
+
+  it('lists multiple packages', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+    await createFakePackage('@dot-ai/ext-identity', '1.0.0', {
+      extensions: ['./dist/index.js'],
+    });
+
+    const result = await listPackages(testDir);
+    expect(result).toHaveLength(2);
+  });
+});
+
+describe('resolvePackages', () => {
+  it('returns empty when no packages', async () => {
+    const result = await resolvePackages(testDir);
+    expect(result.extensions).toEqual([]);
+    expect(result.skills).toEqual([]);
+    expect(result.providers).toEqual([]);
+  });
+
+  it('resolves extension paths from packages with dot-ai field', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await resolvePackages(testDir);
+    expect(result.extensions).toHaveLength(1);
+    expect(result.extensions[0]).toContain('ext-memory');
+    expect(result.extensions[0]).toContain('dist/extension.js');
+  });
+
+  it('skips packages without dot-ai field', async () => {
+    await createFakePackage('some-lib', '2.0.0');
+
+    const result = await resolvePackages(testDir);
+    expect(result.extensions).toHaveLength(0);
+  });
+});
+
+describe('ensurePackagesInstalled', () => {
+  it('skips already installed packages', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai/ext-memory'],
+    );
+
+    expect(result.skipped).toContain('@dot-ai/ext-memory');
+    expect(result.installed).toHaveLength(0);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('skips packages when onMissing returns skip', async () => {
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai/ext-not-there'],
+      async () => 'skip',
+    );
+
+    expect(result.skipped).toContain('@dot-ai/ext-not-there');
+    expect(result.installed).toHaveLength(0);
+  });
+
+  it('errors when onMissing returns error', async () => {
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai/ext-not-there'],
+      async () => 'error',
+    );
+
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].source).toBe('@dot-ai/ext-not-there');
+    expect(result.errors[0].error).toContain('Missing package');
+  });
+
+  it('reports errors for failed installs', async () => {
+    // Use an impossible package name that npm will fail to find
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai-fake-nonexistent-pkg-xyz/no-exist'],
+    );
+
+    expect(result.errors).toHaveLength(1);
+    expect(result.errors[0].source).toBe('@dot-ai-fake-nonexistent-pkg-xyz/no-exist');
+  });
+
+  it('handles npm: prefix in source', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['npm:@dot-ai/ext-memory@1.0.0'],
+    );
+
+    // npm:@dot-ai/ext-memory@1.0.0 → name = @dot-ai/ext-memory → already installed
+    expect(result.skipped).toContain('npm:@dot-ai/ext-memory@1.0.0');
+  });
+
+  it('handles multiple packages', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0', {
+      extensions: ['./dist/extension.js'],
+    });
+
+    const result = await ensurePackagesInstalled(
+      testDir,
+      ['@dot-ai/ext-memory', '@dot-ai/ext-not-there'],
+      async (source) => source.includes('not-there') ? 'skip' : 'install',
+    );
+
+    expect(result.skipped).toContain('@dot-ai/ext-memory');
+    expect(result.skipped).toContain('@dot-ai/ext-not-there');
+  });
+});
+
+describe('parsePackageSource (via ensurePackagesInstalled)', () => {
+  // We test parsePackageSource indirectly through ensurePackagesInstalled
+
+  it('handles scoped package with version', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0');
+
+    const result = await ensurePackagesInstalled(testDir, ['@dot-ai/ext-memory@1.0.0']);
+    // Should find it as already installed (strips version to get name)
+    expect(result.skipped).toContain('@dot-ai/ext-memory@1.0.0');
+  });
+
+  it('handles scoped package without version', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0');
+
+    const result = await ensurePackagesInstalled(testDir, ['@dot-ai/ext-memory']);
+    expect(result.skipped).toContain('@dot-ai/ext-memory');
+  });
+
+  it('handles unscoped package with version', async () => {
+    await createFakePackage('my-ext', '2.0.0');
+
+    const result = await ensurePackagesInstalled(testDir, ['my-ext@2.0.0']);
+    expect(result.skipped).toContain('my-ext@2.0.0');
+  });
+
+  it('handles npm: prefix with scoped package', async () => {
+    await createFakePackage('@dot-ai/ext-memory', '1.0.0');
+
+    const result = await ensurePackagesInstalled(testDir, ['npm:@dot-ai/ext-memory']);
+    expect(result.skipped).toContain('npm:@dot-ai/ext-memory');
+  });
+});

package/src/config.ts

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { homedir } from 'node:os';
 import type { DotAiConfig, ExtensionsConfig } from './types.js';
 
 /**
@@ -61,14 +62,52 @@ function settingsJsonToConfig(json: Record<string, unknown>): DotAiConfig {
   return config;
 }
 
+/**
+ * Merge two configs: global (base) + project (override).
+ * Arrays (paths, packages) are concatenated and deduplicated.
+ * Scalar values from project take precedence.
+ */
+function mergeConfigs(global: DotAiConfig, project: DotAiConfig): DotAiConfig {
+  const merged: DotAiConfig = { ...global, ...project };
+
+  // Merge extensions arrays (global + project, deduplicated)
+  if (global.extensions || project.extensions) {
+    const globalExt = global.extensions ?? {};
+    const projectExt = project.extensions ?? {};
+    merged.extensions = {
+      paths: dedup([...(globalExt.paths ?? []), ...(projectExt.paths ?? [])]),
+      packages: dedup([...(globalExt.packages ?? []), ...(projectExt.packages ?? [])]),
+    };
+    // Clean up empty arrays
+    if (merged.extensions.paths!.length === 0) delete merged.extensions.paths;
+    if (merged.extensions.packages!.length === 0) delete merged.extensions.packages;
+    if (!merged.extensions.paths && !merged.extensions.packages) delete merged.extensions;
+  }
+
+  // Project debug/workspace override global
+  if (project.debug) merged.debug = project.debug;
+  if (project.workspace) merged.workspace = project.workspace;
+
+  return merged;
+}
+
+function dedup(arr: string[]): string[] {
+  return [...new Set(arr)];
+}
+
 /**
  * Load config from workspace root.
- * Tries settings.json first, falls back to empty config.
+ *
+ * Loads from two sources and merges them:
+ * 1. Global: ~/.ai/settings.json (user-level defaults)
+ * 2. Project: {workspaceRoot}/.ai/settings.json (project-level overrides)
+ *
+ * Arrays (packages, extensions) are merged. Scalar values from project win.
  */
 export async function loadConfig(workspaceRoot: string): Promise<DotAiConfig> {
-  const settingsConfig = await loadSettingsJson(workspaceRoot);
-  if (settingsConfig) return settingsConfig;
-  return {};
+  const globalConfig = await loadSettingsJson(homedir()) ?? {};
+  const projectConfig = await loadSettingsJson(workspaceRoot) ?? {};
+  return mergeConfigs(globalConfig, projectConfig);
 }
 
 /**

package/src/extension-loader.ts

@@ -5,77 +5,198 @@ import type { ExtensionAPI } from './extension-api.js';
 import type { LoadedExtension, ToolDefinition, CommandDefinition } from './extension-types.js';
 import type { ExtensionsConfig, Skill, Identity } from './types.js';
 
+function isExtensionFile(name: string): boolean {
+  return name.endsWith('.ts') || name.endsWith('.js');
+}
+
+/**
+ * Resolve extension entry points from a directory.
+ *
+ * Checks for:
+ * 1. package.json with "dot-ai.extensions" field -> returns declared paths
+ * 2. index.ts or index.js -> returns the index file
+ *
+ * Returns resolved paths or null if no entry points found.
+ */
+async function resolveExtensionEntries(dir: string): Promise<string[] | null> {
+  // Check for package.json with "dot-ai" field first
+  try {
+    const pkgPath = join(dir, 'package.json');
+    const pkgRaw = await readFile(pkgPath, 'utf-8');
+    const pkg = JSON.parse(pkgRaw) as Record<string, unknown>;
+    const dotAi = pkg['dot-ai'] as { extensions?: string[] } | undefined;
+    if (dotAi?.extensions && Array.isArray(dotAi.extensions)) {
+      const entries: string[] = [];
+      for (const ext of dotAi.extensions) {
+        const resolvedPath = resolve(dir, ext);
+        try {
+          await stat(resolvedPath);
+          entries.push(resolvedPath);
+        } catch { /* entry doesn't exist */ }
+      }
+      if (entries.length > 0) return entries;
+    }
+  } catch { /* no package.json or invalid */ }
+
+  // Check for index.ts or index.js
+  for (const indexName of ['index.ts', 'index.js']) {
+    const indexPath = join(dir, indexName);
+    try {
+      await stat(indexPath);
+      return [indexPath];
+    } catch { /* not found */ }
+  }
+
+  return null;
+}
+
+/**
+ * Scan a directory for extensions.
+ *
+ * Discovery rules:
+ * 1. Direct files: `dir/*.ts` or `*.js` -> load
+ * 2. Subdirectory with package.json: `dir/sub/package.json` with "dot-ai" field -> load what it declares
+ * 3. Subdirectory with index: `dir/sub/index.ts` or `index.js` -> load
+ *
+ * No recursion beyond one level. Complex packages must use package.json manifest.
+ */
+async function discoverExtensionsInDir(dir: string): Promise<string[]> {
+  const discovered: string[] = [];
+
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const entryPath = join(dir, entry.name);
+
+      // 1. Direct files: *.ts or *.js
+      if (entry.isFile() && isExtensionFile(entry.name)) {
+        discovered.push(entryPath);
+        continue;
+      }
+
+      // 2 & 3. Subdirectories: package.json or index file
+      if (entry.isDirectory()) {
+        const resolved = await resolveExtensionEntries(entryPath);
+        if (resolved) {
+          discovered.push(...resolved);
+        }
+      }
+    }
+  } catch { /* directory doesn't exist — skip */ }
+
+  return discovered;
+}
+
+/**
+ * Resolve extensions from installed packages in .ai/packages/.
+ *
+ * Reads the package.json created by `npm --prefix .ai/packages/` and resolves
+ * extension entry points from each installed package's "dot-ai.extensions" field.
+ */
+async function resolveInstalledPackages(workspaceRoot: string): Promise<string[]> {
+  const packagesDir = join(workspaceRoot, '.ai', 'packages');
+  const pkgJsonPath = join(packagesDir, 'package.json');
+
+  try {
+    const raw = await readFile(pkgJsonPath, 'utf-8');
+    const pkg = JSON.parse(raw) as Record<string, unknown>;
+    const deps = pkg.dependencies as Record<string, string> | undefined;
+    if (!deps) return [];
+
+    const paths: string[] = [];
+    for (const name of Object.keys(deps)) {
+      const pkgDir = join(packagesDir, 'node_modules', name);
+      const entries = await resolveExtensionEntries(pkgDir);
+      if (entries) {
+        paths.push(...entries);
+      }
+    }
+    return paths;
+  } catch {
+    return [];
+  }
+}
+
 /**
- * Discover extension file paths from configured locations.
+ * Discover extension file paths from all sources.
+ *
+ * Sources (in order):
+ * 1. Auto-discovery: .ai/extensions/ (project-local)
+ * 2. Auto-discovery: ~/.ai/extensions/ (global)
+ * 3. Installed packages: .ai/packages/node_modules/ (installed via dot-ai install)
+ * 4. Configured paths: settings.json "extensions" array (explicit paths/dirs)
+ * 5. Configured packages: settings.json "packages" array (npm package names resolved from workspace node_modules)
  */
 export async function discoverExtensions(
   workspaceRoot: string,
   config?: ExtensionsConfig,
 ): Promise<string[]> {
-  const paths = new Set<string>();
+  const seen = new Set<string>();
+  const allPaths: string[] = [];
+
+  const addPaths = (paths: string[]) => {
+    for (const p of paths) {
+      const resolved = resolve(p);
+      if (!seen.has(resolved)) {
+        seen.add(resolved);
+        allPaths.push(resolved);
+      }
+    }
+  };
 
-  // Default discovery paths
-  const searchDirs = [
-    join(workspaceRoot, '.ai', 'extensions'),
-    join(homedir(), '.ai', 'extensions'),
-    ...(config?.paths ?? []).map(p => resolve(workspaceRoot, p)),
-  ];
+  // 1. Project-local extensions: .ai/extensions/
+  addPaths(await discoverExtensionsInDir(join(workspaceRoot, '.ai', 'extensions')));
 
-  for (const dir of searchDirs) {
-    try {
-      const entries = await readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {
-          paths.add(fullPath);
-        } else if (entry.isDirectory()) {
-          // Check for index.ts or index.js
-          for (const indexName of ['index.ts', 'index.js']) {
-            const indexPath = join(fullPath, indexName);
-            try {
-              await stat(indexPath);
-              paths.add(indexPath);
-              break;
-            } catch { /* not found */ }
+  // 2. Global extensions: ~/.ai/extensions/
+  addPaths(await discoverExtensionsInDir(join(homedir(), '.ai', 'extensions')));
+
+  // 3. Installed packages: .ai/packages/node_modules/
+  addPaths(await resolveInstalledPackages(workspaceRoot));
+
+  // 4. Explicitly configured paths from settings.json "extensions" array
+  if (config?.paths) {
+    for (const p of config.paths) {
+      const resolved = resolve(workspaceRoot, p);
+      try {
+        const s = await stat(resolved);
+        if (s.isDirectory()) {
+          // Check for package.json or index file first
+          const entries = await resolveExtensionEntries(resolved);
+          if (entries) {
+            addPaths(entries);
+          } else {
+            // Discover individual files in directory
+            addPaths(await discoverExtensionsInDir(resolved));
           }
-          // Check for package.json with dot-ai field
-          try {
-            const pkgPath = join(fullPath, 'package.json');
-            const pkgRaw = await readFile(pkgPath, 'utf-8');
-            const pkg = JSON.parse(pkgRaw) as Record<string, unknown>;
-            const dotAi = pkg['dot-ai'] as { extensions?: string[] } | undefined;
-            if (dotAi?.extensions && Array.isArray(dotAi.extensions)) {
-              for (const ext of dotAi.extensions) {
-                paths.add(resolve(fullPath, ext));
-              }
-            }
-          } catch { /* no package.json or no dot-ai field */ }
+        } else if (s.isFile()) {
+          addPaths([resolved]);
         }
+      } catch {
+        // Path doesn't exist — add anyway (will fail at load time with clear error)
+        addPaths([resolved]);
       }
-    } catch { /* directory doesn't exist — skip */ }
+    }
   }
 
-  // Also resolve npm packages from config
+  // 5. Configured npm packages from settings.json "packages" array
+  // These are resolved from the workspace's own node_modules
   if (config?.packages) {
     for (const pkg of config.packages) {
       try {
         const { createRequire } = await import('node:module');
         const require = createRequire(join(workspaceRoot, 'package.json'));
         const pkgJsonPath = require.resolve(`${pkg}/package.json`);
-        const pkgRaw = await readFile(pkgJsonPath, 'utf-8');
-        const pkgJson = JSON.parse(pkgRaw) as Record<string, unknown>;
-        const dotAi = pkgJson['dot-ai'] as { extensions?: string[] } | undefined;
-        if (dotAi?.extensions && Array.isArray(dotAi.extensions)) {
-          const pkgDir = join(pkgJsonPath, '..');
-          for (const ext of dotAi.extensions) {
-            paths.add(resolve(pkgDir, ext));
-          }
+        const pkgDir = join(pkgJsonPath, '..');
+        const entries = await resolveExtensionEntries(pkgDir);
+        if (entries) {
+          addPaths(entries);
         }
       } catch { /* package not found */ }
     }
   }
 
-  return Array.from(paths);
+  return allPaths;
 }
 
 /**

package/src/index.ts

@@ -85,8 +85,8 @@ export { NoopLogger, JsonFileLogger, StderrLogger } from './logger.js';
 export { loadConfig, migrateConfig } from './config.js';
 
 // ── Package Manager ──
-export { install, remove, listPackages, resolvePackages } from './package-manager.js';
-export type { PackageInfo } from './package-manager.js';
+export { install, remove, listPackages, resolvePackages, ensurePackagesInstalled } from './package-manager.js';
+export type { PackageInfo, MissingPackageAction } from './package-manager.js';
 
 // ── Boot Cache ──
 export { computeChecksum, loadBootCache, writeBootCache, clearBootCache } from './boot-cache.js';