@ai.ntellect/core 1.0.0 → 1.1.0

package/agent/agent-workflow.ts

@@ -0,0 +1,569 @@
+import { GraphFlow } from "../execution/index";
+import { GraphContext } from "../types";
+import { AgentContext, AgentContextSchema, ScratchpadEntry } from "../types/agent";
+import { AgentLogger } from "./tools/logger";
+import { BaseAgent } from "./base";
+
+export interface CognitiveNodeContext {
+  executor: {
+    makeDecision: (context: AgentContext) => Promise<{ actions: any[]; response: string; thought?: string }>;
+    executeActions: (actions: any[], context: AgentContext) => Promise<void>;
+    updateDynamicGoal: (context: AgentContext) => Promise<string>;
+    reflect: (context: AgentContext) => Promise<{ learning: string; adjustedGoal?: string }>;
+    scheduleTask?: (cron: string, request: string) => Promise<string | null>;
+    decomposeTask?: (actions: any[], context: AgentContext) => Promise<{ groups: any[][]; response: string }>;
+  };
+  baseAgent: BaseAgent;
+  logger: AgentLogger;
+  maxIterations: number;
+  enableClone?: boolean;
+  entityResolver?: {
+    resolve: (ctx: any) => any;
+    getIndex: () => any;
+  };
+  exploreStrategy?: {
+    plan: (candidates: any[], cwd: string) => { type: string; path: string; reason: string }[];
+  };
+}
+
+export function buildAgentWorkflow(ctx: CognitiveNodeContext): GraphFlow<typeof AgentContextSchema> {
+  return new GraphFlow({
+    name: "assistant",
+    schema: AgentContextSchema,
+    context: {
+      input: { raw: "" },
+      actions: [],
+      response: "",
+      executedActions: [],
+      iteration: 0,
+      progressed: false,
+      messages: [],
+      toolResults: {},
+      scratchpad: [],
+      memories: [],
+      entityState: {
+        currentTarget: undefined,
+        lastEntityType: null,
+        pendingResolutions: [],
+        resolutionTrace: [],
+        explored: false,
+      },
+      explorationBudget: {
+        maxSteps: 12,
+        maxExplorations: 2,
+        maxToolCalls: 8,
+        stepsUsed: 0,
+        explorationsUsed: 0,
+        toolCallsUsed: 0,
+      },
+      conversationState: {
+        currentGoal: "",
+        currentTarget: null,
+        lastResolvedEntity: null,
+        lastResolvedType: null,
+        pendingTask: null,
+        turnCount: 0,
+        pendingIntent: null,
+      },
+    },
+    nodes: [
+      {
+        name: "defineGoal",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          const agentContext = context as unknown as AgentContext;
+          await ctx.executor.updateDynamicGoal(agentContext);
+          ctx.logger.info("workflow", "Goal defined");
+        },
+        next: ["recall"],
+      },
+      {
+        name: "recall",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          const agentContext = context as unknown as AgentContext;
+          const query = agentContext.input?.raw || "";
+          const memories = await ctx.baseAgent.recall(query);
+          agentContext.memories = memories || [];
+          if (memories.length > 0) {
+            ctx.logger.info("recall", `Retrieved ${memories.length} relevant memories`);
+          }
+        },
+        next: ["resolve"],
+      },
+      {
+        name: "resolve",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          const agentContext = context as unknown as AgentContext;
+          const input = agentContext.input?.raw || "";
+          if (!input || !ctx.entityResolver) {
+            agentContext.entityState = {
+              currentTarget: undefined,
+              lastEntityType: null,
+              pendingResolutions: [],
+              resolutionTrace: [],
+              explored: false,
+            };
+            return;
+          }
+
+          const cwd = process.cwd();
+          const resolverCtx = {
+            userMessage: input,
+            conversationHistory: agentContext.messages || [],
+            conversationState: agentContext.conversationState || {
+              currentGoal: "", currentTarget: null, lastResolvedEntity: null,
+              lastResolvedType: null, pendingTask: null, turnCount: 0, pendingIntent: null,
+            },
+            cwd,
+            entityIndex: ctx.entityResolver.getIndex(),
+          };
+
+          const result = ctx.entityResolver.resolve(resolverCtx);
+          const trace = result.trace;
+          const confidence = result.confidence;
+
+          // Merge new handles with existing ones from previous turn
+          const existingHandles = agentContext.entityState?.handles || {};
+          const mergedHandles = { ...existingHandles };
+          let handleIdx = Object.keys(mergedHandles).length;
+          for (const [, h] of Object.entries(result.handles || {})) {
+            const entry = h as { id: string; label: string; path: string; category: string };
+            const key = Object.keys(mergedHandles).find(
+              k => mergedHandles[k].path === entry.path
+            );
+            if (key) {
+              mergedHandles[key] = entry;
+            } else {
+              mergedHandles[`ent_${handleIdx++}`] = entry;
+            }
+          }
+
+          // Always ensure at least a cwd handle so LLM can list files
+          if (Object.keys(mergedHandles).length === 0) {
+            mergedHandles.ent_0 = {
+              id: "ent_0",
+              label: cwd.split("/").pop() || "cwd",
+              path: cwd,
+              category: "dir",
+            };
+          }
+
+          agentContext.entityState = {
+            currentTarget: result.resolution.resolved[0]?.resolved?.id || undefined,
+            lastEntityType: result.resolution.resolved[0]?.resolved?.category || null,
+            pendingResolutions: result.resolution.references,
+            resolutionTrace: trace,
+            explored: agentContext.entityState?.explored || false,
+            handles: mergedHandles,
+          };
+
+          if (agentContext.explorationBudget) {
+            agentContext.explorationBudget.stepsUsed++;
+          }
+
+          if (confidence.level !== "high") {
+            const refs = result.resolution.ambiguous;
+            if (refs.length > 0) {
+              ctx.logger.info("resolve", `Confidence ${confidence.level} (${confidence.score.toFixed(2)}): ${refs.length} ambiguous reference(s)`);
+              for (const r of refs) {
+                const handleIds = r.candidates.map((c: any) => {
+                  const found = Object.entries(result.handles || {}).find(([, h]: any) => h.label === c.entity.filename);
+                  return found ? found[0] : "?";
+                });
+                ctx.logger.info("resolve", `  "${r.raw}" → ${r.candidates.map((c: any, i: number) => `${handleIds[i]}=${c.entity.filename}(${(c.breakdown.total * 100).toFixed(0)}%)`).join(", ")}`);
+              }
+            }
+          } else {
+            ctx.logger.info("resolve", `High confidence: ${result.resolution.resolved.map((r: any) => r.resolved?.filename).join(", ") || "no refs"}`);
+          }
+        },
+        next: (context: GraphContext<typeof AgentContextSchema>): any => {
+          const agentContext = context as unknown as AgentContext;
+          const es = agentContext.entityState;
+          const budget = agentContext.explorationBudget;
+          const trace = es?.resolutionTrace as any[] || [];
+          const lastTrace = trace[trace.length - 1];
+
+          if (!lastTrace) return ["think"];
+
+          if (es?.explored && lastTrace.action !== "explored") {
+            const prevConfidence = trace[trace.length - 2]?.confidence;
+            const currConfidence = lastTrace.confidence;
+            if (prevConfidence !== undefined && currConfidence !== undefined && currConfidence <= prevConfidence) {
+              ctx.logger.info("resolve", "Exploration did not improve confidence, proceeding to think");
+              return ["think"];
+            }
+          }
+
+          const isLow = lastTrace.action === "failed" ||
+            (lastTrace.candidates.length > 0 && lastTrace.confidence !== undefined && lastTrace.confidence < 0.3);
+
+          if (isLow && budget && budget.explorationsUsed < budget.maxExplorations) {
+            return ["explore"];
+          }
+
+          if (isLow && budget && budget.explorationsUsed >= budget.maxExplorations) {
+            ctx.logger.info("resolve", "Max explorations reached, proceeding with ambiguity");
+          }
+
+          return ["think"];
+        },
+      },
+      {
+        name: "explore",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          const agentContext = context as unknown as AgentContext;
+          const entityState = agentContext.entityState;
+          if (!entityState?.pendingResolutions?.length || !ctx.exploreStrategy || !ctx.entityResolver) {
+            ctx.logger.info("explore", "Nothing to explore");
+            return;
+          }
+
+          const allCandidates = entityState.pendingResolutions.flatMap((r: any) => r.candidates || []);
+          const cwd = process.cwd();
+          const plans = ctx.exploreStrategy.plan(allCandidates, cwd);
+
+          if (plans.length === 0) {
+            ctx.logger.info("explore", "No exploration actions planned");
+            return;
+          }
+
+          const fs = await import("fs/promises");
+          const index = ctx.entityResolver.getIndex();
+
+          ctx.logger.info("explore", `Exploring ${plans.length} location(s): ${plans.map((p: any) => p.path).join(", ")}`);
+
+          for (const plan of plans) {
+            if (plan.type !== "directory_lister") continue;
+            try {
+              const entries = await fs.readdir(plan.path, { withFileTypes: true });
+              const entryList = entries.map((e: any) => ({
+                name: e.name,
+                type: e.isDirectory() ? "directory" : "file",
+              }));
+              index.ingestDirectory(plan.path, entryList);
+              ctx.logger.info("explore", `Listed ${plan.path}: ${entryList.length} entries`);
+            } catch (e: any) {
+              ctx.logger.warn("explore", `Failed to list ${plan.path}: ${e.message}`);
+            }
+          }
+
+          if (agentContext.explorationBudget) {
+            agentContext.explorationBudget.explorationsUsed++;
+          }
+          entityState.explored = true;
+          ctx.logger.info("explore", "Exploration complete, re-resolving...");
+        },
+        next: ["resolve"],
+      },
+      {
+        name: "think",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          const agentContext = context as unknown as AgentContext;
+          const iter = (agentContext.iteration ?? 0) + 1;
+          agentContext.iteration = iter;
+          if (iter >= ctx.maxIterations) {
+            context.response = context.response || "Max iterations reached.";
+            ctx.logger.warn("workflow", `Max iterations (${ctx.maxIterations}) reached`);
+            return;
+          }
+
+          const pendingActions = agentContext.actions || [];
+          const executedKeys = new Set(
+            (agentContext.executedActions || []).map((a: any) => {
+              const p = a.parameters || {};
+              const normalized = Array.isArray(p) ? Object.fromEntries(p.map((x: any) => [x.name, x.value])) : p;
+              return `${a.name}:${JSON.stringify(normalized)}`;
+            })
+          );
+          const allAlreadyDone = pendingActions.length > 0 && pendingActions.every((a: any) => {
+            const params = a.parameters || {};
+            const normalized = Array.isArray(params) ? Object.fromEntries(params.map((x: any) => [x.name, x.value])) : params;
+            return executedKeys.has(`${a.name}:${JSON.stringify(normalized)}`);
+          });
+
+          if (allAlreadyDone) {
+            ctx.logger.info("think", `All ${pendingActions.length} action(s) already executed, generating final response from tool results`);
+            agentContext.actions = [];
+            const decision = await ctx.executor.makeDecision(agentContext);
+            context.response = decision.response;
+            context.actions = [];
+            const entry: ScratchpadEntry = {
+              turn: iter,
+              thought: decision.thought || "All actions already done, generating final response.",
+              action: "final_response",
+              observation: decision.response,
+              timestamp: new Date().toISOString(),
+            };
+            if (!agentContext.scratchpad) agentContext.scratchpad = [];
+            agentContext.scratchpad.push(entry);
+            ctx.logger.think("think", `Decision: 0 actions`, decision.response);
+            return;
+          }
+
+          ctx.logger.info("think", `Iteration ${iter}: Analyzing context...`);
+          const decision = await ctx.executor.makeDecision(agentContext);
+          context.actions = decision.actions;
+          context.response = decision.response;
+          (context as any)._parallelGroups = undefined;
+
+          const entry: ScratchpadEntry = {
+            turn: iter,
+            thought: decision.thought || "No explicit reasoning.",
+            action: decision.actions.length > 0
+              ? decision.actions.map((a: any) => a.name).join(", ")
+              : "direct_response",
+            observation: decision.response,
+            timestamp: new Date().toISOString(),
+          };
+          if (!agentContext.scratchpad) agentContext.scratchpad = [];
+          agentContext.scratchpad.push(entry);
+
+          ctx.logger.think("think", `Decision: ${decision.actions.length} actions`, decision.response);
+        },
+        next: (context: GraphContext<typeof AgentContextSchema>): any => {
+          const agentContext = context as unknown as AgentContext;
+          const iter = agentContext.iteration ?? 0;
+          if (agentContext.actions.length === 0 || iter >= ctx.maxIterations) {
+            return ["reply"];
+          }
+          if (ctx.enableClone && ctx.executor.decomposeTask && agentContext.actions.length > 1) {
+            return ["decompose"];
+          }
+          return ["execute"];
+        },
+      },
+      {
+        name: "decompose",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          const agentContext = context as unknown as AgentContext;
+          ctx.logger.info("decompose", `Analyzing ${agentContext.actions.length} actions for parallelization...`);
+          const result = await ctx.executor.decomposeTask!(agentContext.actions, agentContext);
+          if (result.groups.length > 1) {
+            (context as any)._parallelGroups = result.groups;
+            ctx.logger.info("decompose", `Split into ${result.groups.length} parallel groups`);
+          }
+          context.response = result.response;
+        },
+        next: ["execute"],
+      },
+      {
+        name: "execute",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          const timestamp = new Date().toISOString();
+          const agentContext = context as unknown as AgentContext;
+
+          const normalizeParams = (p: any): Record<string, any> => {
+            if (Array.isArray(p)) {
+              const obj: Record<string, any> = {};
+              for (const item of p) obj[item.name] = item.value;
+              return obj;
+            }
+            return p || {};
+          };
+
+          const makeKey = (name: string, params: any): string =>
+            `${name}:${JSON.stringify(normalizeParams(params))}`;
+
+          const executedKeys = new Set(
+            (agentContext.executedActions || []).map((a: any) => makeKey(a.name, a.parameters))
+          );
+
+          const newActions = (agentContext.actions || []).filter((a: any) => {
+            if (executedKeys.has(makeKey(a.name, a.parameters))) {
+              ctx.logger.info("dedup", `Skipping: ${a.name} (already executed)`);
+              return false;
+            }
+            return true;
+          });
+
+          if (newActions.length === 0) {
+            agentContext.actions = [];
+            agentContext.progressed = false;
+            ctx.logger.info("execute", "No actions to execute");
+            return;
+          }
+          agentContext.progressed = true;
+
+          ctx.logger.info("execute", `Executing ${newActions.length} tools...`);
+
+          const results = (agentContext.executedActions || []).map((a: any) =>
+            `${a.name}: ${JSON.stringify(a.result)}`
+          ).join('\n');
+          agentContext.knowledge = `Date: ${timestamp}\n${results}`;
+
+          if (ctx.entityResolver) {
+            const index = ctx.entityResolver.getIndex();
+            for (const action of newActions) {
+              const params = normalizeParams(action.parameters || {});
+              if (params.path) {
+                index.ingestFile(params.path);
+              }
+            }
+          }
+
+          const parallelGroups = (context as any)._parallelGroups;
+          if (parallelGroups && parallelGroups.length > 1) {
+            ctx.logger.info("execute", `Executing ${parallelGroups.length} groups in parallel...`);
+            await Promise.all(parallelGroups.map((group: any[]) =>
+              ctx.executor.executeActions(group, agentContext)
+            ));
+          } else {
+            await ctx.executor.executeActions(newActions, agentContext);
+          }
+
+          if (ctx.entityResolver) {
+            const index = ctx.entityResolver.getIndex();
+            for (const a of newActions) {
+              const params = normalizeParams(a.parameters || {});
+              if (a.name === "directory_lister" && params.path) {
+                const found = agentContext.executedActions?.slice().reverse().find(e => e.name === "directory_lister");
+                const entries = found?.result?.entries;
+                if (entries) {
+                  index.ingestDirectory(params.path, entries);
+                }
+              }
+            }
+          }
+
+          for (const a of newActions) {
+            const found = agentContext.executedActions?.slice().reverse().find(e => e.name === a.name);
+            if (found) {
+              if (!agentContext.toolResults) agentContext.toolResults = {};
+              agentContext.toolResults[a.name] = found.result;
+            }
+          }
+
+          // Detect if all newly executed actions failed → halt loop
+          const newlyExecuted = agentContext.executedActions?.slice(-newActions.length) || [];
+          const allFailed = newlyExecuted.length > 0 && newlyExecuted.every(a => {
+            const r = a.result || {};
+            return (
+              (typeof r.content === 'string' && r.content.startsWith('Error:')) ||
+              r.success === false ||
+              (a.name === 'directory_lister' && r.entries && Array.isArray(r.entries) && r.entries.length === 0) ||
+              (['shell', 'node_code', 'python_code'].includes(a.name) && (r.exitCode > 0 || r.error))
+            );
+          });
+          if (allFailed) {
+            agentContext.progressed = false;
+            ctx.logger.warn("execute", "All actions failed, halting planning loop");
+          }
+
+          agentContext.actions = [];
+          (context as any)._parallelGroups = undefined;
+        },
+        next: (context: GraphContext<typeof AgentContextSchema>): any => {
+          const agentContext = context as unknown as AgentContext;
+          const iter = agentContext.iteration ?? 0;
+          if (iter >= ctx.maxIterations || !agentContext.progressed) {
+            return ["reply"];
+          }
+          return ["reflect"];
+        },
+      },
+      {
+        name: "reflect",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          const agentContext = context as unknown as AgentContext;
+          ctx.logger.info("reflect", "Reflecting on last actions...");
+          const reflection = await ctx.executor.reflect(agentContext);
+
+          const entry: ScratchpadEntry = {
+            turn: agentContext.iteration ?? 0,
+            thought: "Post-action reflection",
+            action: "reflection",
+            observation: reflection.learning,
+            timestamp: new Date().toISOString(),
+          };
+          if (!agentContext.scratchpad) agentContext.scratchpad = [];
+          agentContext.scratchpad.push(entry);
+
+          if (reflection.learning && ctx.baseAgent) {
+            try {
+              await ctx.baseAgent.execute({
+                type: "reflection",
+                content: reflection.learning,
+                metadata: {
+                  turn: agentContext.iteration,
+                  timestamp: new Date().toISOString(),
+                },
+              });
+              ctx.logger.info("reflect", "Reflection stored in memory");
+            } catch {
+              ctx.logger.warn("reflect", "Failed to store reflection in memory");
+            }
+          }
+        },
+        next: ["think"],
+      },
+      {
+        name: "plan",
+        execute: async () => {
+          ctx.logger.info("plan", "Planning next steps...");
+        },
+        next: ["think"],
+      },
+      {
+        name: "schedule",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          ctx.logger.info("schedule", "Scheduling a task...");
+          const scheduledTask = (context as any).scheduledTask;
+          if (scheduledTask?.cronExpression && scheduledTask?.request && ctx.executor.scheduleTask) {
+            await ctx.executor.scheduleTask(scheduledTask.cronExpression, scheduledTask.request);
+            context.response = "Tâche planifiée avec succès.";
+          } else {
+            context.response = "Pas de tâche à planifier.";
+          }
+        },
+        next: ["think"],
+      },
+      {
+        name: "reply",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          const agentContext = context as unknown as AgentContext;
+          ctx.logger.info("reply", `Response: ${context.response?.substring(0, 50)}...`);
+          const messages = agentContext.messages || [];
+          const userMsg = agentContext.input?.raw;
+          const lastMsg = messages[messages.length - 1];
+          if (userMsg && (lastMsg?.role !== "user" || lastMsg.content !== userMsg)) {
+            messages.push({ role: "user", content: userMsg });
+          }
+          if (context.response) {
+            const afterUser = messages[messages.length - 1];
+            if (afterUser?.role !== "assistant" || afterUser.content !== context.response) {
+              messages.push({ role: "assistant", content: context.response });
+            }
+          }
+          agentContext.messages = messages;
+
+          const pad = agentContext.scratchpad || [];
+          const thoughtLog = pad.map(e => `[T${e.turn}] ${e.thought} → ${e.action}: ${e.observation}`).join("\n");
+          if (ctx.baseAgent) {
+            try {
+              await ctx.baseAgent.execute({
+                type: "episode",
+                content: `User: ${userMsg || ""}\nAgent: ${context.response || ""}\nThoughts:\n${thoughtLog}`,
+                metadata: {
+                  turn: agentContext.iteration,
+                  timestamp: new Date().toISOString(),
+                },
+              });
+              ctx.logger.info("reply", "Episode stored in memory");
+            } catch {
+              ctx.logger.warn("reply", "Failed to store episode in memory");
+            }
+          }
+        },
+        next: [],
+      },
+      {
+        name: "ask",
+        execute: async (context: GraphContext<typeof AgentContextSchema>) => {
+          ctx.logger.info("ask", "Asking clarification question...");
+          context.response = context.response || "Avez-vous besoin de précisions ?";
+        },
+        next: ["think"],
+      },
+    ],
+  });
+}