agent-state-machine 2.1.8 → 2.2.0

package/lib/runtime/agent.js

@@ -12,6 +12,7 @@ import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
 import { getCurrentRuntime } from './runtime.js';
 import { formatInteractionPrompt } from './interaction.js';
+import { withChangeTracking } from './track-changes.js';
 
 const require = createRequire(import.meta.url);
 
@@ -164,25 +165,37 @@ async function executeJSAgent(runtime, agentPath, name, params, options = {}) {
     _config: {
       models: runtime.workflowConfig.models,
       apiKeys: runtime.workflowConfig.apiKeys,
-      workflowDir: runtime.workflowDir
+      workflowDir: runtime.workflowDir,
+      projectRoot: runtime.workflowConfig.projectRoot
     }
   };
 
-  let result = await handler(context);
-  let interactionDepth = 0;
-
-  // Handle interaction response from JS agent (support multiple rounds)
-  while (result && result._interaction) {
-    const interactionResponse = await handleInteraction(runtime, result._interaction, name);
-    const resumedContext = { ...context, userResponse: interactionResponse };
-    await logAgentStart(runtime, name);
-    result = await handler(resumedContext);
-    interactionDepth += 1;
-    if (interactionDepth > 5) {
-      throw new Error(`Agent ${name} exceeded maximum interaction depth`);
+  // Execute handler with optional file change tracking
+  const executeHandler = async () => {
+    let result = await handler(context);
+    let interactionDepth = 0;
+
+    // Handle interaction response from JS agent (support multiple rounds)
+    while (result && result._interaction) {
+      const interactionResponse = await handleInteraction(runtime, result._interaction, name);
+      const resumedContext = { ...context, userResponse: interactionResponse };
+      await logAgentStart(runtime, name);
+      result = await handler(resumedContext);
+      interactionDepth += 1;
+      if (interactionDepth > 5) {
+        throw new Error(`Agent ${name} exceeded maximum interaction depth`);
+      }
     }
-  }
 
+    return result;
+  };
+
+  let result;
+  if (runtime.workflowConfig.fileTracking !== false) {
+    result = await withChangeTracking(runtime, name, executeHandler);
+  } else {
+    result = await executeHandler();
+  }
 
   // Clean internal properties from result
   if (result && typeof result === 'object') {
@@ -191,6 +204,7 @@ async function executeJSAgent(runtime, agentPath, name, params, options = {}) {
     delete cleanResult._config;
     delete cleanResult._loop;
     delete cleanResult._interaction;
+    delete cleanResult._files;
 
     // If agent returned a context-like object, only return non-internal keys
     const meaningfulKeys = Object.keys(cleanResult).filter((k) => !k.startsWith('_'));
@@ -235,127 +249,141 @@ async function executeMDAgent(runtime, agentPath, name, params, options = {}) {
     ? runtime.loadSteeringFiles(steeringNames)
     : runtime.steering;
 
-  let response = null;
-  let output = null;
-  let interactionDepth = 0;
-  let currentParams = params;
-
-  while (true) {
-    // Build context - only spread params, NOT memory (explicit context passing)
-    const context = {
-      ...currentParams,
-      _steering: steeringContext,
-      _config: {
-        models: runtime.workflowConfig.models,
-        apiKeys: runtime.workflowConfig.apiKeys,
-        workflowDir: runtime.workflowDir
-      }
-    };
-
-    // Interpolate variables in prompt
-    const interpolatedPrompt = interpolatePrompt(prompt, context);
+  // Build base config (used for all iterations)
+  const baseConfig = {
+    models: runtime.workflowConfig.models,
+    apiKeys: runtime.workflowConfig.apiKeys,
+    workflowDir: runtime.workflowDir,
+    projectRoot: runtime.workflowConfig.projectRoot
+  };
 
-    const model = config.model || 'fast';
+  // Execute the MD agent core logic
+  const executeMDAgentCore = async () => {
+    let response = null;
+    let output = null;
+    let interactionDepth = 0;
+    let currentParams = params;
+
+    while (true) {
+      // Build context - only spread params, NOT memory (explicit context passing)
+      const context = {
+        ...currentParams,
+        _steering: steeringContext,
+        _config: baseConfig
+      };
+
+      // Interpolate variables in prompt
+      const interpolatedPrompt = interpolatePrompt(prompt, context);
+
+      const model = config.model || 'fast';
+
+      const fullPrompt = buildPrompt(context, {
+        model,
+        prompt: interpolatedPrompt,
+        includeContext: config.includeContext !== 'false',
+        responseType: config.response
+      });
 
-    const fullPrompt = buildPrompt(context, {
-      model,
-      prompt: interpolatedPrompt,
-      includeContext: config.includeContext !== 'false',
-      responseType: config.response
-    });
+      await logAgentStart(runtime, name, fullPrompt);
 
-    await logAgentStart(runtime, name, fullPrompt);
+      console.log(`    Using model: ${model}`);
 
-    console.log(`    Using model: ${model}`);
+      response = await llm(context, {
+        model: model,
+        prompt: interpolatedPrompt,
+        includeContext: config.includeContext !== 'false',
+        responseType: config.response
+      });
 
-    response = await llm(context, {
-      model: model,
-      prompt: interpolatedPrompt,
-      includeContext: config.includeContext !== 'false',
-      responseType: config.response
-    });
+      // Parse output based on format
+      output = response.text;
+      if (config.format === 'json') {
+        try {
+          output = parseJSON(response.text);
+        } catch {
+          console.warn(`    Warning: Failed to parse JSON output`);
+        }
+      }
 
-    // Parse output based on format
-    output = response.text;
-    if (config.format === 'json') {
-      try {
-        output = parseJSON(response.text);
-      } catch {
-        console.warn(`    Warning: Failed to parse JSON output`);
+      if (output && typeof output === 'object' && output._interaction) {
+        const interactionResponse = await handleInteraction(runtime, output._interaction, name);
+        currentParams = { ...params, userResponse: interactionResponse };
+        interactionDepth += 1;
+        if (interactionDepth > 5) {
+          throw new Error(`Agent ${name} exceeded maximum interaction depth`);
+        }
+        continue;
       }
+
+      break;
     }
 
-    if (output && typeof output === 'object' && output._interaction) {
-      const interactionResponse = await handleInteraction(runtime, output._interaction, name);
-      currentParams = { ...params, userResponse: interactionResponse };
-      interactionDepth += 1;
-      if (interactionDepth > 5) {
-        throw new Error(`Agent ${name} exceeded maximum interaction depth`);
+    // Check for interaction request
+    const parsedInteraction = parseInteractionRequest(response.text);
+    const structuredInteraction =
+      config.autoInteract !== 'false' && parsedInteraction.isInteraction;
+
+    // Check if agent returned an 'interact' object in its JSON response
+    const hasInteractKey = output && typeof output === 'object' && output.interact;
+
+    // Explicit interaction mode (format: interaction OR interaction: true)
+    // But only trigger if agent actually wants to interact (has interact key or parsed interaction)
+    const explicitInteraction =
+      config.format === 'interaction' ||
+      ((config.interaction === 'true' || (typeof config.interaction === 'string' && config.interaction.length > 0)) &&
+        (hasInteractKey || structuredInteraction));
+
+    if (explicitInteraction || structuredInteraction) {
+      // Use interact object if present, otherwise fall back to parsed/raw
+      const interactionData = hasInteractKey ? output.interact : (structuredInteraction ? parsedInteraction : null);
+
+      const slugRaw =
+        interactionData?.slug ||
+        (typeof config.interaction === 'string' && config.interaction !== 'true'
+          ? config.interaction
+          : null) ||
+        config.interactionSlug ||
+        config.interactionKey ||
+        name;
+
+      const slug = sanitizeSlug(slugRaw);
+      const targetKey = config.interactionKey || outputKey || slug;
+
+      // Build interaction object with full metadata
+      const interactionObj = hasInteractKey ? {
+        ...output.interact,
+        slug,
+        targetKey
+      } : {
+        slug,
+        targetKey,
+        content: structuredInteraction ? parsedInteraction.question : response.text
+      };
+
+      const userResponse = await handleInteraction(runtime, interactionObj, name);
+
+      // Return the user's response as the agent result
+      if (outputKey) {
+        return { [outputKey]: userResponse, _debug_prompt: response.fullPrompt };
       }
-      continue;
-    }
 
-    break;
-  }
+      return userResponse;
+    }
 
-  // Check for interaction request
-  const parsedInteraction = parseInteractionRequest(response.text);
-  const structuredInteraction =
-    config.autoInteract !== 'false' && parsedInteraction.isInteraction;
-
-  // Check if agent returned an 'interact' object in its JSON response
-  const hasInteractKey = output && typeof output === 'object' && output.interact;
-
-  // Explicit interaction mode (format: interaction OR interaction: true)
-  // But only trigger if agent actually wants to interact (has interact key or parsed interaction)
-  const explicitInteraction =
-    config.format === 'interaction' ||
-    ((config.interaction === 'true' || (typeof config.interaction === 'string' && config.interaction.length > 0)) &&
-      (hasInteractKey || structuredInteraction));
-
-  if (explicitInteraction || structuredInteraction) {
-    // Use interact object if present, otherwise fall back to parsed/raw
-    const interactionData = hasInteractKey ? output.interact : (structuredInteraction ? parsedInteraction : null);
-    
-    const slugRaw =
-      interactionData?.slug ||
-      (typeof config.interaction === 'string' && config.interaction !== 'true'
-        ? config.interaction
-        : null) ||
-      config.interactionSlug ||
-      config.interactionKey ||
-      name;
-
-    const slug = sanitizeSlug(slugRaw);
-    const targetKey = config.interactionKey || outputKey || slug;
-    
-    // Build interaction object with full metadata
-    const interactionObj = hasInteractKey ? {
-      ...output.interact,
-      slug,
-      targetKey
-    } : {
-      slug,
-      targetKey,
-      content: structuredInteraction ? parsedInteraction.question : response.text
-    };
-
-    const userResponse = await handleInteraction(runtime, interactionObj, name);
-
-    // Return the user's response as the agent result
+    // Return result object
     if (outputKey) {
-      return { [outputKey]: userResponse, _debug_prompt: response.fullPrompt };
+      return { [outputKey]: output, _debug_prompt: response.fullPrompt };
     }
 
-    return userResponse;
-  }
+    return output;
+  };
 
-  // Return result object
-  if (outputKey) {
-    return { [outputKey]: output, _debug_prompt: response.fullPrompt };
+  // Execute with optional file change tracking
+  if (runtime.workflowConfig.fileTracking !== false) {
+    return withChangeTracking(runtime, name, executeMDAgentCore);
+  } else {
+    return executeMDAgentCore();
   }
-
-  return output;
 }
 
 /**

package/lib/runtime/model-resolution.js

@@ -0,0 +1,128 @@
+/**
+ * File: /lib/runtime/model-resolution.js
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { askHuman } from './prompt.js';
+import { createInteraction, parseInteractionResponse } from './interaction.js';
+import { readModelFromConfig, writeModelToConfig } from '../config-utils.js';
+
+function sanitizeSlug(value) {
+  return String(value)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .substring(0, 40) || 'model';
+}
+
+export function buildModelSuggestions(availableCLIs = {}, existingModels = {}) {
+  const options = [];
+  const lookup = {};
+
+  const addOption = (key, label, description, value) => {
+    options.push({ key, label, description });
+    lookup[key] = value;
+  };
+
+  Object.entries(existingModels).forEach(([key, value]) => {
+    const optionKey = `existing:${key}`;
+    const description = value ? `Maps to "${value}"` : 'Existing model mapping';
+    addOption(optionKey, `Use existing model: ${key}`, description, value);
+  });
+
+  if (availableCLIs.claude) {
+    addOption('cli:claude', 'claude -p', 'Claude CLI (print mode)', 'claude -p');
+  }
+  if (availableCLIs.gemini) {
+    addOption('cli:gemini', 'gemini', 'Gemini CLI', 'gemini');
+  }
+  if (availableCLIs.codex) {
+    addOption('cli:codex', 'codex', 'Codex CLI (exec)', 'codex');
+  }
+  if (availableCLIs.ollama) {
+    addOption('cli:ollama', 'ollama run llama3.1', 'Ollama CLI (example model)', 'ollama run llama3.1');
+  }
+
+  addOption(
+    'api:openai',
+    'api:openai:gpt-4.1-mini',
+    'OpenAI API (example model)',
+    'api:openai:gpt-4.1-mini'
+  );
+  addOption(
+    'api:anthropic',
+    'api:anthropic:claude-3-5-sonnet-20241022',
+    'Anthropic API (example model)',
+    'api:anthropic:claude-3-5-sonnet-20241022'
+  );
+
+  return { options, lookup };
+}
+
+export async function promptForModelConfig(modelKey, existingModels = {}, availableCLIs = {}) {
+  const existingKeys = Object.keys(existingModels);
+  const existingSummary = existingKeys.length > 0
+    ? `Existing models: ${existingKeys.join(', ')}`
+    : 'No models configured yet.';
+
+  const { options, lookup } = buildModelSuggestions(availableCLIs, existingModels);
+  const prompt = `Unknown model key: "${modelKey}"\n\nHow would you like to configure this model?\n${existingSummary}`;
+  const slug = `model-${sanitizeSlug(modelKey)}`;
+  const interaction = createInteraction('choice', slug, {
+    prompt,
+    options,
+    allowCustom: true,
+    multiSelect: false
+  });
+
+  const answer = await askHuman(prompt, { slug, interaction });
+  const parsed = await parseInteractionResponse(interaction, answer);
+
+  if (parsed.isCustom && parsed.customText) {
+    return parsed.customText.trim();
+  }
+
+  if (parsed.selectedKey) {
+    const mapped = lookup[parsed.selectedKey];
+    if (mapped) return mapped;
+    return String(parsed.selectedKey).trim();
+  }
+
+  if (typeof parsed.text === 'string' && parsed.text.trim()) {
+    return parsed.text.trim();
+  }
+
+  if (typeof parsed.raw === 'string' && parsed.raw.trim()) {
+    return parsed.raw.trim();
+  }
+
+  throw new Error('No model configuration provided.');
+}
+
+export async function resolveUnknownModel(modelKey, config, workflowDir, options = {}) {
+  if (!workflowDir) {
+    throw new Error('Cannot resolve model without a workflow directory.');
+  }
+
+  const configFile = path.join(workflowDir, 'config.js');
+  if (!fs.existsSync(configFile)) {
+    throw new Error(`config.js not found in ${workflowDir}`);
+  }
+
+  const existing = readModelFromConfig(configFile, modelKey);
+  if (existing) {
+    return existing;
+  }
+
+  const existingModels = config?.models || {};
+  const availableCLIs = options.availableCLIs || {};
+  const modelValue = await promptForModelConfig(modelKey, existingModels, availableCLIs);
+
+  if (!modelValue) {
+    throw new Error('Model configuration cannot be empty.');
+  }
+
+  writeModelToConfig(configFile, modelKey, modelValue);
+  return modelValue;
+}

package/lib/runtime/runtime.js

@@ -12,6 +12,7 @@ import readline from 'readline';
 import { pathToFileURL } from 'url';
 import { createMemoryProxy } from './memory.js';
 import { RemoteClient } from '../remote/client.js';
+import { DEFAULT_IGNORE } from '../file-tree.js';
 
 // Global runtime reference for agent() and memory access
 // stored on globalThis to ensure singleton access across different module instances (CLI vs local)
@@ -74,7 +75,12 @@ export class WorkflowRuntime {
     this.workflowConfig = {
       models: {},
       apiKeys: {},
-      description: ''
+      description: '',
+      // File tracking defaults
+      projectRoot: path.resolve(workflowDir, '../..'),
+      fileTracking: true,
+      fileTrackingIgnore: DEFAULT_IGNORE,
+      fileTrackingKeepDeleted: false
     };
 
     // Load steering
@@ -317,7 +323,12 @@ export class WorkflowRuntime {
       this.workflowConfig = {
         models: cfg.models || {},
         apiKeys: cfg.apiKeys || {},
-        description: cfg.description || ''
+        description: cfg.description || '',
+        // File tracking configuration
+        projectRoot: cfg.projectRoot || path.resolve(this.workflowDir, '../..'),
+        fileTracking: cfg.fileTracking ?? true,
+        fileTrackingIgnore: cfg.fileTrackingIgnore || DEFAULT_IGNORE,
+        fileTrackingKeepDeleted: cfg.fileTrackingKeepDeleted ?? false
       };
 
       // Import workflow module