@dot-ai/core 0.5.2 → 0.8.0

package/src/config.ts

@@ -1,178 +1,176 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import type { DotAiConfig, ProviderConfig } from './types.js';
-import { discoverNodes, parseScanDirs } from './nodes.js';
+import type { DotAiConfig, ExtensionsConfig } from './types.js';
 
 /**
- * Inject the workspace root into all provider sections of a DotAiConfig.
- * This ensures file-based providers resolve paths relative to the workspace.
+ * Load settings.json (Pi-compatible format).
+ *
+ * Format:
+ * {
+ *   "packages": ["npm:@dot-ai/ext-cockpit@1.0.0"],
+ *   "extensions": [".ai/extensions/custom.ts"],
+ *   "debug": { "logPath": "..." },
+ *   "workspace": { "scanDirs": "..." }
+ * }
+ */
+async function loadSettingsJson(workspaceRoot: string): Promise<DotAiConfig | null> {
+  const settingsPath = join(workspaceRoot, '.ai', 'settings.json');
+  try {
+    const raw = await readFile(settingsPath, 'utf-8');
+    const json = JSON.parse(raw);
+    return settingsJsonToConfig(json);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Convert Pi-compatible settings.json to DotAiConfig.
  */
-export function injectRoot(config: DotAiConfig, root: string): DotAiConfig {
-  // Discover workspace nodes
-  const globalScanDirs = parseScanDirs(config.workspace?.scanDirs ?? 'projects');
-  const nodes = discoverNodes(root, globalScanDirs);
-
-  const result: DotAiConfig = {};
-  const providerKeys = ['memory', 'skills', 'identity', 'routing', 'tasks', 'tools'] as const;
-  for (const key of providerKeys) {
-    const section = config[key];
-    if (section && typeof section === 'object') {
-      result[key] = {
-        ...section,
-        with: { root, nodes, ...(section.with ?? {}) },
-      };
+function settingsJsonToConfig(json: Record<string, unknown>): DotAiConfig {
+  const config: DotAiConfig = {};
+
+  // Extensions: string[] of local paths
+  const extensions = json['extensions'];
+  const packages = json['packages'];
+
+  if ((extensions && Array.isArray(extensions)) || (packages && Array.isArray(packages))) {
+    config.extensions = {};
+    if (extensions && Array.isArray(extensions)) {
+      config.extensions.paths = extensions.filter((e): e is string => typeof e === 'string');
+    }
+    if (packages && Array.isArray(packages)) {
+      config.extensions.packages = packages.filter((p): p is string => typeof p === 'string');
     }
   }
-  // Preserve non-provider sections
-  if (config.debug) {
-    result.debug = config.debug;
+
+  // Debug section
+  if (json['debug'] && typeof json['debug'] === 'object') {
+    const debug = json['debug'] as Record<string, unknown>;
+    config.debug = {};
+    if (typeof debug['logPath'] === 'string') config.debug.logPath = debug['logPath'];
   }
-  if (config.workspace) {
-    result.workspace = config.workspace;
+
+  // Workspace section
+  if (json['workspace'] && typeof json['workspace'] === 'object') {
+    const ws = json['workspace'] as Record<string, unknown>;
+    config.workspace = {};
+    if (typeof ws['scanDirs'] === 'string') config.workspace.scanDirs = ws['scanDirs'];
   }
-  return result;
+
+  return config;
 }
 
 /**
- * Load and parse dot-ai.yml from a workspace root.
- * Returns the config with defaults applied.
- *
- * Uses a minimal YAML parser (key: value pairs + nested objects).
- * No dependency on yaml package.
+ * Load config from workspace root.
+ * Tries settings.json first, falls back to empty config.
  */
 export async function loadConfig(workspaceRoot: string): Promise<DotAiConfig> {
-  const configPath = join(workspaceRoot, '.ai', 'dot-ai.yml');
+  const settingsConfig = await loadSettingsJson(workspaceRoot);
+  if (settingsConfig) return settingsConfig;
+  return {};
+}
 
+/**
+ * Migrate dot-ai.yml to settings.json.
+ * Reads the existing YAML config and writes a settings.json equivalent.
+ * Returns the path of the written file, or null if no YAML config exists.
+ */
+export async function migrateConfig(workspaceRoot: string): Promise<string | null> {
+  const ymlPath = join(workspaceRoot, '.ai', 'dot-ai.yml');
   let raw: string;
   try {
-    raw = await readFile(configPath, 'utf-8');
+    raw = await readFile(ymlPath, 'utf-8');
   } catch {
-    // No config file — return empty config (all defaults)
-    return {};
+    return null; // No YAML config to migrate
   }
 
-  return parseYaml(raw);
+  // Extract extensions section from YAML if present
+  const config: DotAiConfig = {};
+  const extensions = parseExtensionsFromYaml(raw);
+  if (extensions) {
+    config.extensions = extensions;
+  }
+
+  const settings = configToSettingsJson(config);
+  const settingsPath = join(workspaceRoot, '.ai', 'settings.json');
+  const { writeFile: wf } = await import('node:fs/promises');
+  await wf(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  return settingsPath;
 }
 
 /**
- * Resolve a config with defaults.
- * Any missing provider gets the built-in file-based default.
+ * Convert DotAiConfig to Pi-compatible settings.json format.
  */
-export interface ResolvedConfig {
-  memory: ProviderConfig;
-  skills: ProviderConfig;
-  identity: ProviderConfig;
-  routing: ProviderConfig;
-  tasks: ProviderConfig;
-  tools: ProviderConfig;
-  debug?: import('./types.js').DebugConfig;
-}
-
-export function resolveConfig(config: DotAiConfig): ResolvedConfig {
-  return {
-    memory: config.memory ?? { use: '@dot-ai/provider-file-memory' },
-    skills: config.skills ?? { use: '@dot-ai/provider-file-skills' },
-    identity: config.identity ?? { use: '@dot-ai/provider-file-identity' },
-    routing: config.routing ?? { use: '@dot-ai/provider-rules-routing' },
-    tasks: config.tasks ?? { use: '@dot-ai/provider-file-tasks' },
-    tools: config.tools ?? { use: '@dot-ai/provider-file-tools' },
-    debug: config.debug,
-  };
-}
-
-// ── Minimal YAML parser ─────────────────────────────────────────────────────
+function configToSettingsJson(config: DotAiConfig): Record<string, unknown> {
+  const settings: Record<string, unknown> = {};
 
-interface YamlNode {
-  [key: string]: string | YamlNode;
-}
-
-function stripQuotes(s: string): string {
-  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
-    return s.slice(1, -1);
+  if (config.extensions?.paths?.length) {
+    settings['extensions'] = config.extensions.paths;
   }
-  return s;
+  if (config.extensions?.packages?.length) {
+    settings['packages'] = config.extensions.packages;
+  }
+  if (config.debug) settings['debug'] = config.debug;
+  if (config.workspace) settings['workspace'] = config.workspace;
+
+  return settings;
 }
 
-function parseYaml(raw: string): DotAiConfig {
+/**
+ * Parse extensions section from legacy YAML config.
+ */
+function parseExtensionsFromYaml(raw: string): ExtensionsConfig | null {
+  const extensions: ExtensionsConfig = {};
   const lines = raw.split('\n');
-  const result: YamlNode = {};
-  let currentSection: string | null = null;
+  let inExtensions = false;
+  let currentKey: 'paths' | 'packages' | null = null;
 
   for (const line of lines) {
-    // Skip comments and empty lines
-    if (line.trim().startsWith('#') || line.trim() === '') continue;
-
-    // Top-level key (no indent)
-    const topMatch = line.match(/^(\w+):$/);
-    if (topMatch) {
-      currentSection = topMatch[1];
-      result[currentSection] = {};
+    if (line.match(/^extensions:$/)) {
+      inExtensions = true;
       continue;
     }
-
-    // Nested key: value (2-space indent)
-    const nestedMatch = line.match(/^  (\w+):\s*(.+)$/);
-    if (nestedMatch && currentSection) {
-      const section = result[currentSection] as YamlNode;
-      let value = stripQuotes(nestedMatch[2].trim());
-
-      // Resolve ${ENV_VAR} references
-      value = value.replace(/\$\{(\w+)\}/g, (_, name: string) => process.env[name] ?? '');
-
-      section[nestedMatch[1]] = value;
+    if (inExtensions && line.match(/^\w+:/) && !line.match(/^extensions:/)) {
+      break;
+    }
+    if (!inExtensions) continue;
+
+    const inlineArrayMatch = line.match(/^\s{2}(\w+):\s*\[(.+)\]$/);
+    if (inlineArrayMatch) {
+      const key = inlineArrayMatch[1] as 'paths' | 'packages';
+      const items = inlineArrayMatch[2]
+        .split(',')
+        .map(s => stripQuotes(s.trim()))
+        .filter(s => s.length > 0);
+      extensions[key] = items;
+      currentKey = null;
       continue;
     }
 
-    // Deeper nested key: value (4-space indent) for 'with' block
-    const deepMatch = line.match(/^    (\w+):\s*(.+)$/);
-    if (deepMatch && currentSection) {
-      const section = result[currentSection] as YamlNode;
-      if (!section['with'] || typeof section['with'] === 'string') {
-        section['with'] = {};
-      }
-      let value = stripQuotes(deepMatch[2].trim());
-      value = value.replace(/\$\{(\w+)\}/g, (_, name: string) => process.env[name] ?? '');
-      (section['with'] as YamlNode)[deepMatch[1]] = value;
+    const keyMatch = line.match(/^\s{2}(\w+):$/);
+    if (keyMatch) {
+      currentKey = keyMatch[1] as 'paths' | 'packages';
+      extensions[currentKey] = [];
+      continue;
     }
-  }
 
-  // Convert YamlNode to DotAiConfig
-  const config: DotAiConfig = {};
-  const providerKeys = ['memory', 'skills', 'identity', 'routing', 'tasks', 'tools'] as const;
-
-  for (const key of providerKeys) {
-    const section = result[key];
-    if (section && typeof section === 'object') {
-      const node = section as YamlNode;
-      const providerConfig: ProviderConfig = {
-        use: typeof node['use'] === 'string' ? node['use'] : '',
-      };
-      if (node['with'] && typeof node['with'] === 'object') {
-        providerConfig.with = node['with'] as Record<string, unknown>;
-      }
-      config[key] = providerConfig;
+    const listItemMatch = line.match(/^\s{4}-\s*(.+)$/);
+    if (listItemMatch && currentKey) {
+      if (!extensions[currentKey]) extensions[currentKey] = [];
+      extensions[currentKey]!.push(stripQuotes(listItemMatch[1].trim()));
     }
   }
 
-  // Parse debug section
-  const debugSection = result['debug'];
-  if (debugSection && typeof debugSection === 'object') {
-    const node = debugSection as YamlNode;
-    config.debug = {};
-    if (typeof node['logPath'] === 'string') {
-      config.debug.logPath = node['logPath'];
-    }
+  if (extensions.paths?.length || extensions.packages?.length) {
+    return extensions;
   }
+  return null;
+}
 
-  // Parse workspace section
-  const workspaceSection = result['workspace'];
-  if (workspaceSection && typeof workspaceSection === 'object') {
-    const node = workspaceSection as YamlNode;
-    config.workspace = {};
-    if (typeof node['scanDirs'] === 'string') {
-      config.workspace.scanDirs = node['scanDirs'];
-    }
+function stripQuotes(s: string): string {
+  if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+    return s.slice(1, -1);
   }
-
-  return config;
+  return s;
 }

package/src/extension-api.ts

@@ -0,0 +1,99 @@
+import type {
+  ContextInjectEvent, ContextInjectResult,
+  ContextModifyEvent, ContextModifyResult,
+  ToolCallEvent, ToolCallResult,
+  ToolResultEvent,
+  AgentEndEvent,
+  ToolDefinition,
+  ExtensionContext,
+  ResourcesDiscoverResult,
+  LabelExtractEvent,
+  ContextEnrichEvent, ContextEnrichResult,
+  RouteEvent, RouteResult,
+  InputEvent, InputResult,
+  CommandDefinition,
+} from './extension-types.js';
+import type { Label } from './types.js';
+
+/**
+ * v6 Extension Context — passed as second argument to every event handler.
+ * Extends the base ExtensionContext with labels and optional agent capabilities.
+ */
+export interface ExtensionContextV6 extends ExtensionContext {
+  /** Current prompt labels (available after label_extract) */
+  labels: Label[];
+
+  /** Agent capabilities (adapter-provided, may be undefined) */
+  agent?: {
+    abort(): void;
+    getContextUsage(): { tokens: number; percent: number } | undefined;
+    getSystemPrompt(): string;
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * Extension API — passed to extension factory functions.
+ * Pi-compatible: same on(event) + registerTool() + registerCommand() pattern.
+ */
+export interface ExtensionAPI {
+  // ── Event subscription ──
+
+  /** Resource discovery: extensions declare resources and contribute labels */
+  on(event: 'resources_discover', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<ResourcesDiscoverResult | void>): void;
+  /** Label extraction: extensions can add custom labels (chain-transform) */
+  on(event: 'label_extract', handler: (e: LabelExtractEvent, ctx: ExtensionContextV6) => Promise<Label[] | void>): void;
+  /** Context enrichment: extensions return sections for context injection */
+  on(event: 'context_enrich', handler: (e: ContextEnrichEvent, ctx: ExtensionContextV6) => Promise<ContextEnrichResult | void>): void;
+  /** Model routing: first result wins */
+  on(event: 'route', handler: (e: RouteEvent, ctx: ExtensionContextV6) => Promise<RouteResult | void>): void;
+  /** Input transformation: extensions can rewrite user input */
+  on(event: 'input', handler: (e: InputEvent, ctx: ExtensionContextV6) => Promise<InputResult | void>): void;
+  /** Tool call interception: fired before tool execution, can block */
+  on(event: 'tool_call', handler: (e: ToolCallEvent, ctx: ExtensionContextV6) => Promise<ToolCallResult | void>): void;
+  /** Tool result observation: fired after tool execution */
+  on(event: 'tool_result', handler: (e: ToolResultEvent, ctx: ExtensionContextV6) => Promise<void>): void;
+
+  // ── Lifecycle events ──
+
+  on(event: 'session_start', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
+  on(event: 'session_end', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
+  on(event: 'agent_start', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
+  on(event: 'agent_end', handler: (e: AgentEndEvent, ctx: ExtensionContextV6) => Promise<void>): void;
+  on(event: 'turn_start', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
+  on(event: 'turn_end', handler: (e: undefined, ctx: ExtensionContextV6) => Promise<void>): void;
+
+  // ── Legacy events (kept for transition) ──
+
+  /** @deprecated Use context_enrich instead */
+  on(event: 'context_inject', handler: (e: ContextInjectEvent, ctx: ExtensionContextV6) => Promise<ContextInjectResult | void>): void;
+  /** @deprecated Use context_enrich instead */
+  on(event: 'context_modify', handler: (e: ContextModifyEvent, ctx: ExtensionContextV6) => Promise<ContextModifyResult | void>): void;
+
+  // ── Catch-all for custom/Pi-specific events ──
+
+  on(event: string, handler: (e: any, ctx: ExtensionContextV6) => Promise<any>): void;
+
+  // ── Capability registration ──
+
+  /** Register a tool that the agent can invoke */
+  registerTool(tool: ToolDefinition): void;
+  /** Register a command (slash command, etc.) */
+  registerCommand(command: CommandDefinition): void;
+
+  // ── Inter-extension communication ──
+
+  events: {
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    off(event: string, handler: (...args: unknown[]) => void): void;
+    emit(event: string, ...args: unknown[]): void;
+  };
+
+  // ── Extension config ──
+
+  /** Extension configuration (from extension-specific config files, env vars, etc.) */
+  config: Record<string, unknown>;
+
+  /** Workspace root directory (contains .ai/) */
+  workspaceRoot: string;
+}

package/src/extension-loader.ts

@@ -0,0 +1,127 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import type { ExtensionAPI } from './extension-api.js';
+import type { LoadedExtension, ToolDefinition, CommandDefinition, ExtensionTier } from './extension-types.js';
+import { EVENT_TIERS } from './extension-types.js';
+import type { ExtensionsConfig } from './types.js';
+
+/**
+ * Discover extension file paths from configured locations.
+ */
+export async function discoverExtensions(
+  workspaceRoot: string,
+  config?: ExtensionsConfig,
+): Promise<string[]> {
+  const paths = new Set<string>();
+
+  // Default discovery paths
+  const searchDirs = [
+    join(workspaceRoot, '.ai', 'extensions'),
+    join(homedir(), '.ai', 'extensions'),
+    ...(config?.paths ?? []).map(p => resolve(workspaceRoot, p)),
+  ];
+
+  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 */ }
+          }
+          // 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 */ }
+        }
+      }
+    } catch { /* directory doesn't exist — skip */ }
+  }
+
+  // Also resolve npm packages from config
+  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));
+          }
+        }
+      } catch { /* package not found */ }
+    }
+  }
+
+  return Array.from(paths);
+}
+
+/**
+ * Create a v6 ExtensionAPI instance that collects registrations into a LoadedExtension.
+ * Extensions communicate via events only — no provider access.
+ */
+export function createV6CollectorAPI(
+  extensionPath: string,
+  config: Record<string, unknown>,
+  eventBus?: { on: (event: string, handler: (...args: unknown[]) => void) => void; emit: (event: string, ...args: unknown[]) => void },
+  workspaceRoot?: string,
+): { api: ExtensionAPI; extension: LoadedExtension } {
+  const extension: LoadedExtension = {
+    path: extensionPath,
+    handlers: new Map(),
+    tools: new Map(),
+    commands: new Map(),
+    tiers: new Set(),
+  };
+
+  const api: ExtensionAPI = {
+    on(event: string, handler: Function) {
+      if (!extension.handlers.has(event)) {
+        extension.handlers.set(event, []);
+      }
+      extension.handlers.get(event)!.push(handler);
+
+      const tier: ExtensionTier | undefined = EVENT_TIERS[event];
+      if (tier) {
+        extension.tiers.add(tier);
+      }
+    },
+    registerTool(tool: ToolDefinition) {
+      extension.tools.set(tool.name, tool);
+    },
+    registerCommand(command: CommandDefinition) {
+      extension.commands.set(command.name, command);
+    },
+    events: eventBus ?? {
+      on: () => {},
+      emit: () => {},
+    },
+    config,
+    workspaceRoot: workspaceRoot ?? process.cwd(),
+  } as unknown as ExtensionAPI;
+
+  return { api, extension };
+}