@almadar/agent 1.1.3 → 1.1.4

package/dist/agent/index.d.ts

@@ -1,251 +1,12 @@
-import { LLMProvider } from '@almadar/llm';
-import { S as SubagentEventCallback, O as OrbitalCompleteCallback, D as DomainOrbitalCompleteCallback } from '../orbital-subagent-cNfTLdXQ.js';
-import { BaseCheckpointSaver } from '@langchain/langgraph-checkpoint';
-import { P as PersistenceMode, b as FirestoreDb, d as SessionMetadata, e as SessionRecord } from '../firestore-checkpointer-DxbQ10ve.js';
+export { E as EVENT_BUDGETS, S as SessionManager, d as SessionManagerOptions, e as Skill, f as SkillAgentOptions, g as SkillAgentResult, h as SkillLoader, i as SkillMeta, j as SkillRefLoader, l as createSkillAgent, m as getBudgetWarningMessage, n as getEventBudget, o as getInterruptConfig, r as resumeSkillAgent } from '../index-wLhxy6Gb.js';
 export { Command } from '@langchain/langgraph';
+export { P as PersistenceMode, d as SessionMetadata, e as SessionRecord } from '../firestore-checkpointer-DxbQ10ve.js';
+import '@almadar/llm';
+import '../orbital-subagent-cNfTLdXQ.js';
 import '@langchain/core/tools';
 import 'zod';
 import '../api-types-BW_58thJ.js';
 import '@almadar/core/types';
+import '@langchain/langgraph-checkpoint';
+import '@almadar/core';
 import '@langchain/core/runnables';
-
-/**
- * Session Manager
- *
- * Unified session management API with pluggable persistence backends.
- * Supports in-memory (development) and Firestore (production) backends.
- */
-
-interface SessionManagerOptions {
-    /**
-     * Persistence mode.
-     * @default 'memory'
-     */
-    mode?: PersistenceMode;
-    /**
-     * Firestore database instance. Required when mode is 'firestore'.
-     */
-    firestoreDb?: FirestoreDb;
-}
-/**
- * Unified session management for agent sessions.
- *
- * Handles both session metadata and LangGraph checkpointers.
- */
-declare class SessionManager {
-    private mode;
-    private memoryBackend;
-    private memoryCheckpointers;
-    private firestoreCheckpointer;
-    private firestoreSessionStore;
-    constructor(options?: SessionManagerOptions);
-    /**
-     * Get the persistence mode.
-     */
-    getMode(): PersistenceMode;
-    /**
-     * Get or create a checkpointer for a session.
-     */
-    getCheckpointer(threadId: string): BaseCheckpointSaver<any>;
-    /**
-     * Store session metadata.
-     */
-    store(threadId: string, metadata: SessionMetadata): void;
-    /**
-     * Get session metadata (sync, memory only).
-     */
-    get(threadId: string): SessionMetadata | undefined;
-    /**
-     * Get session metadata (async, supports Firestore).
-     */
-    getAsync(threadId: string): Promise<SessionMetadata | undefined>;
-    /**
-     * Clear a session's checkpointer and metadata.
-     */
-    clear(threadId: string): boolean;
-    /**
-     * List all sessions (sync, memory only).
-     */
-    list(): SessionRecord[];
-    /**
-     * List all sessions (async, supports Firestore).
-     */
-    listAsync(): Promise<SessionRecord[]>;
-}
-
-/**
- * Skill-Based DeepAgent Factory
- *
- * Creates DeepAgent instances that use skills as the primary prompt source.
- * No custom system prompts - all agent behavior is defined through skills.
- *
- * Uses deepagents library primitives:
- * - createDeepAgent() for agent creation
- * - FilesystemBackend for file operations
- *
- * Skill loading is injected via SkillLoader functions, keeping this package
- * independent of any specific skill registry location.
- */
-
-/**
- * Skill definition loaded by the consumer.
- */
-interface Skill {
-    name: string;
-    description: string;
-    content: string;
-    allowedTools?: string[];
-    version?: string;
-    references: string[];
-    path?: string;
-}
-/**
- * Function to load a skill by name.
- */
-type SkillLoader = (name: string) => Skill | null;
-/**
- * Function to load a skill reference by skill name and ref name.
- */
-type SkillRefLoader = (skillName: string, refName: string) => string | null;
-/**
- * Options for creating a skill agent.
- */
-interface SkillAgentOptions {
-    /** Required: The skill(s) to use. Can be a single skill or array of skills. */
-    skill: string | string[];
-    /** Required: Working directory for the agent */
-    workDir: string;
-    /** Required: Function to load skills */
-    skillLoader: SkillLoader;
-    /** Optional: Function to load skill references */
-    skillRefLoader?: SkillRefLoader;
-    /** Optional: Thread ID for session continuity */
-    threadId?: string;
-    /** Optional: LLM provider */
-    provider?: LLMProvider;
-    /** Optional: Model name */
-    model?: string;
-    /** Optional: Enable verbose logging */
-    verbose?: boolean;
-    /** Optional: Disable human-in-the-loop interrupts (for eval/testing) */
-    noInterrupt?: boolean;
-    /** Optional: Callback for subagent events (orbital generation) */
-    onSubagentEvent?: SubagentEventCallback;
-    /** Optional: Session manager instance (shared across requests) */
-    sessionManager?: SessionManager;
-    /** Optional: Extracted requirements from analysis phase (for orbital skill) */
-    requirements?: {
-        entities?: string[];
-        states?: string[];
-        events?: string[];
-        guards?: string[];
-        pages?: string[];
-        effects?: string[];
-        rawRequirements?: string[];
-    };
-    /** Optional: GitHub integration configuration */
-    githubConfig?: {
-        /** GitHub personal access token */
-        token: string;
-        /** Repository owner (e.g., 'octocat') */
-        owner?: string;
-        /** Repository name (e.g., 'hello-world') */
-        repo?: string;
-    };
-}
-/**
- * Result from creating a skill agent.
- */
-interface SkillAgentResult {
-    /** The agent instance (from deepagents library) */
-    agent: any;
-    /** Thread ID for session resumption */
-    threadId: string;
-    /** The loaded skill(s) - primary skill when single, all skills when multiple */
-    skill: Skill;
-    /** All loaded skills (same as skill when single) */
-    skills: Skill[];
-    /** Working directory */
-    workDir: string;
-    /** Orbital tool setter for wiring SSE callback (if orbital tool enabled) */
-    setOrbitalEventCallback?: (callback: SubagentEventCallback) => void;
-    /** Orbital tool setter for wiring persistence callback */
-    setOrbitalCompleteCallback?: (callback: OrbitalCompleteCallback) => void;
-    /** Domain orbital callback for lean skill Firestore persistence */
-    setDomainCompleteCallback?: (callback: DomainOrbitalCompleteCallback) => void;
-}
-/**
- * Create a skill-based DeepAgent.
- *
- * Uses the specified skill's content as the system prompt.
- * When multiple skills are provided, the agent sees all skill descriptions
- * and can choose the appropriate one based on the user's request.
- *
- * @throws Error if any skill is not found
- */
-declare function createSkillAgent(options: SkillAgentOptions): Promise<SkillAgentResult>;
-/**
- * Resume a skill agent session.
- *
- * Loads the skill from session metadata and creates agent with same threadId.
- *
- * @throws Error if session not found
- */
-declare function resumeSkillAgent(threadId: string, options: {
-    verbose?: boolean;
-    noInterrupt?: boolean;
-    skillLoader: SkillLoader;
-    skillRefLoader?: SkillRefLoader;
-    sessionManager?: SessionManager;
-}): Promise<SkillAgentResult>;
-
-/**
- * Event Budget Configuration
- *
- * Prevents runaway agent loops with soft/hard event limits per skill.
- */
-/**
- * Event budget limits for different skills.
- * - soft: Warning threshold (agent reminded to finish up)
- * - hard: Maximum events before forced completion
- */
-declare const EVENT_BUDGETS: Record<string, {
-    soft: number;
-    hard: number;
-}>;
-/**
- * Get event budget for a skill.
- */
-declare function getEventBudget(skillName: string): {
-    soft: number;
-    hard: number;
-};
-/**
- * Generate a budget warning message to inject into the agent.
- */
-declare function getBudgetWarningMessage(eventCount: number, budget: {
-    soft: number;
-    hard: number;
-}): string | null;
-
-/**
- * Interrupt Configuration
- *
- * Human-in-the-loop configuration for agent tools.
- */
-/**
- * Skill metadata (minimal interface for interrupt config).
- */
-interface SkillMeta {
-    name: string;
-    allowedTools?: string[];
-}
-/**
- * Get interrupt configuration for a skill.
- *
- * Default: require approval for execute tool.
- * Skills can override via frontmatter (future enhancement).
- */
-declare function getInterruptConfig(_skill: SkillMeta): Record<string, boolean>;
-
-export { EVENT_BUDGETS, PersistenceMode, SessionManager, type SessionManagerOptions, SessionMetadata, SessionRecord, type Skill, type SkillAgentOptions, type SkillAgentResult, type SkillLoader, type SkillMeta, type SkillRefLoader, createSkillAgent, getBudgetWarningMessage, getEventBudget, getInterruptConfig, resumeSkillAgent };

package/dist/agent/index.js

@@ -3520,10 +3520,30 @@ ${skillSummaries}
 
 ${skillContents}`;
   }
+  let userPreferences = null;
+  let projectContext = null;
+  if (options.memoryManager && options.userId) {
+    try {
+      userPreferences = await options.memoryManager.getUserPreferences(options.userId);
+      if (userPreferences && verbose) {
+        console.log(`[SkillAgent] Loaded user preferences: ${userPreferences.namingConvention} naming, ${userPreferences.preferredPatterns.length} patterns`);
+      }
+      if (options.appId) {
+        projectContext = await options.memoryManager.getProjectContext(options.appId);
+        if (projectContext && verbose) {
+          console.log(`[SkillAgent] Loaded project context: ${projectContext.existingEntities.length} entities`);
+        }
+      }
+    } catch (error) {
+      console.warn("[SkillAgent] Failed to load memory:", error);
+    }
+  }
+  const memoryContext = buildMemoryContext(userPreferences, projectContext);
   const systemPrompt = [
     BASE_SYSTEM_PROMPT,
     "\n## Skill Instructions\n\n" + skillInstructions,
-    references ? "\n## Reference Documentation\n\n" + references : ""
+    references ? "\n## Reference Documentation\n\n" + references : "",
+    memoryContext ? "\n## User Context\n\n" + memoryContext : ""
   ].filter(Boolean).join("\n");
   const threadId = providedThreadId || v4();
   const llmClient = createLLMClient(provider, model, verbose);
@@ -3626,9 +3646,54 @@ ${skillContents}`;
     workDir,
     setOrbitalEventCallback,
     setOrbitalCompleteCallback,
-    setDomainCompleteCallback
+    setDomainCompleteCallback,
+    userPreferences,
+    projectContext,
+    memoryManager: options.memoryManager
   };
 }
+function buildMemoryContext(userPreferences, projectContext) {
+  const sections = [];
+  if (userPreferences) {
+    const prefs = [];
+    if (userPreferences.namingConvention) {
+      prefs.push(`- Preferred naming: ${userPreferences.namingConvention}`);
+    }
+    if (userPreferences.validationStyle) {
+      prefs.push(`- Validation style: ${userPreferences.validationStyle}`);
+    }
+    if (userPreferences.preferredPatterns.length > 0) {
+      prefs.push(`- Preferred patterns: ${userPreferences.preferredPatterns.join(", ")}`);
+    }
+    if (userPreferences.commonEntities.length > 0) {
+      prefs.push(`- Commonly used entities: ${userPreferences.commonEntities.join(", ")}`);
+    }
+    if (prefs.length > 0) {
+      sections.push(`### User Preferences
+${prefs.join("\n")}`);
+    }
+  }
+  if (projectContext) {
+    const ctx = [];
+    if (projectContext.projectName) {
+      ctx.push(`- Project: ${projectContext.projectName}`);
+    }
+    if (projectContext.domain) {
+      ctx.push(`- Domain: ${projectContext.domain}`);
+    }
+    if (projectContext.existingEntities.length > 0) {
+      ctx.push(`- Existing entities: ${projectContext.existingEntities.join(", ")}`);
+    }
+    if (projectContext.conventions.length > 0) {
+      ctx.push(`- Project conventions: ${projectContext.conventions.join(", ")}`);
+    }
+    if (ctx.length > 0) {
+      sections.push(`### Project Context
+${ctx.join("\n")}`);
+    }
+  }
+  return sections.length > 0 ? sections.join("\n\n") : null;
+}
 async function resumeSkillAgent(threadId, options) {
   const sessions = options.sessionManager ?? getDefaultSessionManager();
   const metadata = sessions.get(threadId);