Go

Author: ericmourant

.github-minimum-intelligence/lifecycle/local-chat.ts

@@ -112,6 +112,12 @@ const piSettingsPath = resolve(minimumIntelligenceDir, ".pi", "settings.json");
 const memoryLogPath = resolve(minimumIntelligenceDir, "memory.log");
 const lastRunRawPath = resolve(stateDir, "local-last-run.jsonl");
 
+// Dedicated pi agent dir used only in local mode. Pointing PI_CODING_AGENT_DIR
+// here makes pi read our generated models.json (a custom OpenAI-compatible
+// provider) without disturbing the user's global ~/.pi/agent config.
+const localAgentDir = resolve(stateDir, "pi-agent");
+const localModelsPath = resolve(localAgentDir, "models.json");
+
 // Repo-root-relative session dir, matching agent.ts.
 const sessionsDirRelative = ".github-minimum-intelligence/state/sessions";
 
@@ -146,12 +152,11 @@ const LOCAL_BRAND_DEFAULTS: Record<string, { label: string; baseUrl: string }> =
   vllm:     { label: "vLLM",      baseUrl: "http://localhost:8000/v1"  },
 };
 
-// Brand labels that map to a "openai-compatible" pi invocation. The key is
-// what the user types or configures; the value is what pi actually receives
-// (always "openai" today because pi has no first-class lmstudio/ollama/vllm
-// provider — they all speak OpenAI Chat Completions).
+// Local brands (lmstudio/ollama/vllm) are registered as first-class custom
+// providers in a generated models.json (see ensureLocalProviderConfig), so pi
+// receives the brand name verbatim and reaches the local server over the
+// OpenAI Chat Completions API. The brand IS the pi provider name now.
 function resolvePiProvider(userProvider: string): string {
-  if (LOCAL_PROVIDERS.has(userProvider)) return "openai";
   return userProvider;
 }
 
@@ -740,6 +745,59 @@ function isLocalProvider(provider: string): boolean {
   return false;
 }
 
+/**
+ * Resolve the effective OpenAI-compatible base URL for a local provider,
+ * honouring explicit env vars first, then well-known brand defaults.
+ */
+function resolveLocalBaseUrl(provider: string): string {
+  return (
+    process.env.LOCAL_LLM_BASE_URL ||
+    process.env.OPENAI_BASE_URL ||
+    LOCAL_BRAND_DEFAULTS[provider]?.baseUrl ||
+    "http://localhost:1234/v1"
+  );
+}
+
+/**
+ * Configure pi to talk to a local OpenAI-compatible server (LM Studio, Ollama,
+ * vLLM, or an `openai` provider pointed at LOCAL_LLM_BASE_URL).
+ *
+ * Why this exists: pi's built-in `openai` provider ignores OPENAI_BASE_URL and
+ * defaults to the Responses API, so it would contact the real api.openai.com
+ * and fail with a 401.  The supported mechanism for a local server is a
+ * `models.json` describing a custom provider with an explicit `baseUrl` and the
+ * `openai-completions` API.  pi only reads `models.json` from its agent dir, so
+ * we point PI_CODING_AGENT_DIR at a repo-local directory and write the file
+ * there.  This leaves the user's global ~/.pi/agent untouched and is applied
+ * only for local providers.
+ *
+ * `compat.supportsDeveloperRole` / `supportsReasoningEffort` are disabled
+ * because many local servers reject the `developer` role and the
+ * `reasoning_effort` parameter used by reasoning-capable cloud models.
+ */
+function ensureLocalProviderConfig(provider: string, model: string): void {
+  const baseUrl = resolveLocalBaseUrl(provider);
+  mkdirSync(localAgentDir, { recursive: true });
+  const modelsConfig = {
+    providers: {
+      [provider]: {
+        baseUrl,
+        api: "openai-completions",
+        apiKey: "local",
+        compat: {
+          supportsDeveloperRole: false,
+          supportsReasoningEffort: false,
+        },
+        models: [{ id: model }],
+      },
+    },
+  };
+  writeFileSync(localModelsPath, JSON.stringify(modelsConfig, null, 2) + "\n");
+  process.env.PI_CODING_AGENT_DIR = localAgentDir;
+  process.env.OPENAI_BASE_URL = baseUrl;
+  if (!process.env.OPENAI_API_KEY) process.env.OPENAI_API_KEY = "local";
+}
+
 // ─── pi binary location ───────────────────────────────────────────────────────
 
 function locatePiBin(): string {
@@ -831,11 +889,12 @@ async function runTurn(
       : null;
 
     // Map brand providers (lmstudio/ollama/vllm) to what pi actually
-    // understands today (openai-compatible Chat Completions). pi has no
-    // first-class lmstudio provider, so the brand is purely a label for
-    // the user; the wire-format is always openai-compatible.
+    // understands. For local mode we (re)write models.json so pi reaches the
+    // local OpenAI-compatible server via a custom provider of the same name;
+    // doing it here also picks up runtime /model and /provider switches.
     const piProvider = resolvePiProvider(rt.provider);
     const localMode = isLocalProvider(rt.provider);
+    if (localMode) ensureLocalProviderConfig(rt.provider, rt.model);
     const args: string[] = [
       "--mode", "json",
       "--tools", "read,bash,edit,write,grep,find,ls",
@@ -856,6 +915,10 @@ async function runTurn(
     try {
       const proc = Bun.spawn([rt.piBin, ...args], {
         cwd: repoRoot,
+        // Pass env explicitly so runtime mutations (e.g. PI_CODING_AGENT_DIR
+        // and OPENAI_BASE_URL set by ensureLocalProviderConfig) reliably reach
+        // the pi child on every platform.
+        env: { ...process.env },
         stdout: "pipe",
         stderr: "inherit",
       });
@@ -1811,6 +1874,11 @@ async function main(): Promise<void> {
     piBin,
   };
 
+  // For local providers, generate models.json and point PI_CODING_AGENT_DIR at
+  // it up front so the REPL banner shows the right endpoint and the first turn
+  // is correctly wired.
+  if (isLocalProvider(rt.provider)) ensureLocalProviderConfig(rt.provider, rt.model);
+
   // One-shot mode.
   if (args.prompt) {
     try {

.gitignore

@@ -6,6 +6,12 @@ node_modules/
 # Local-only chat threads created by lifecycle/local-chat.ts
 .github-minimum-intelligence/state/threads/
 
+# Per-session transcripts written to state/sessions
+.github-minimum-intelligence/state/sessions/
+
+# Generated pi agent dir for local mode (models.json, etc.)
+.github-minimum-intelligence/state/pi-agent/
+
 # Per-thread scratch / debug artefacts written by local-chat.ts
 .github-minimum-intelligence/state/local-last-run.jsonl
 .github-minimum-intelligence/memory.log

chat_agent.py

@@ -0,0 +1,106 @@
+# chat_agent.py
+import datetime
+from collections import deque
+
+class ContextualAgent:
+    """
+    A sophisticated class designed to simulate a highly contextual AI chat agent.
+    It models deep understanding by managing explicit memory, short-term context, 
+    and external knowledge retrieval.
+    """
+    
+    def __init__(self, max_context_size=10):
+        # --- Memory Components ---
+        # 1. Long-Term Memory (LTM): Permanent facts learned over time.
+        self.ltm = {}  # Key: Topic/Concept, Value: Summary of insights
+        
+        # 2. Short-Term Context (STM): Recent conversation history for immediate reference.
+        # Using deque to automatically manage the size (sliding window).
+        self.stm = deque(maxlen=max_context_size)
+        
+        print("Agent Initialized: Core context buffers established.")
+
+    def log_interaction(self, user_input: str, agent_response: str):
+        """Records the current exchange in Short-Term Memory (STM)."""
+        log = f"[User]: {user_input} | [Agent]: {agent_response}"
+        self.stm.append((datetime.datetime.now(), log))
+
+    def retrieve_memory(self, query: str) -> str:
+        """Simulates complex knowledge retrieval across LTM and STM."""
+        retrieval = []
+        
+        # Check STM first (immediate relevance)
+        for timestamp, log in list(self.stm):
+            if query.lower() in log.lower():
+                retrieval.append(f"[RECENT CONTEXT]: {log}")
+
+        # Check LTM second (deep knowledge recall)
+        # In a real system, this would involve vector databases and semantic search.
+        for topic, summary in self.ltm.items():
+            if query.lower() in topic.lower() or "memory" in query.lower(): # Simple trigger check for demo
+                retrieval.append(f"[LONG-TERM KNOWLEDGE]: Regarding '{topic}', remember: {summary}")
+
+        if not retrieval:
+            return "\n[Memory Retrieval]: No specific memory matches the current context."
+        else:
+            return "\n" + "\n---\n".join(retrieval)
+
+
+    def process_request(self, user_input: str):
+        """
+        The core logic flow for generating a contextual response. 
+        This is where 'intelligence' resides.
+        """
+        print("\n--- Thinking Process Initiated ---")
+        # Step 1: Retrieve relevant memory before responding (Contextual grounding)
+        memory = self.retrieve_memory(user_input)
+        print("🔍 Memory Check Complete:", memory if "Memory" in memory else "None found.")
+
+        # Step 2: Hypothetical Knowledge Lookup / External Tool Use
+        # In a real system, this would call APIs (e.g., Google Search, Code Interpreter).
+        print("[Tool]: Querying external knowledge bases for deep context...")
+        knowledge_retrieved = "\n[TOOL OUTPUT]: Found related concepts in cosmology and philosophy."
+
+        # Step 3: Synthesis & Response Generation
+        final_response = f"""\n🧠 Agent Synthesis:\nBased on the user's input, we must synthesize the recent conversation ({memory.strip()}) with external knowledge ({knowledge_retrieved.strip()}). \n\n"The core of the answer lies not in retrieval, but in identifying the underlying pattern that connects these two disparate fields..."\n"""
+        
+        # Step 4: Update Memory (Learning)
+        self._learn(user_input, final_response)
+        
+        return final_response
+
+    def _learn(self, user_input: str, response: str):
+        """Updates Long-Term Memory based on successful interactions."""
+        # Simple learning heuristic: if the conversation touches upon a key concept (like 'blue' or 'memory'), store it.
+        if "blue" in user_input.lower() and "deep" in response.lower():
+            self.ltm['The Blue Sky'] = "The sky is best analyzed as a metaphysical placeholder for human potentiality, reflecting cosmic indifference."
+        elif "memory" in user_input.lower():
+            self.ltm['The Nature of Memory'] = "Memory is not a recording; it is an active reconstruction process prone to bias and emotional filtering."
+
+# --- DEMONSTRATION ---
+
+if __name__ == "__main__":
+    agent = ContextualAgent(max_context_size=5)
+    
+    print("\n=========================================")
+    print("--- Simulation: Initial Query (Memory Check) ---")
+    user1 = "What are the deepest philosophical implications of constant change?"
+    response1 = agent.process_request(user1)
+    print(f"\n[Final Agent Output]: {response1}")
+    agent.log_interaction(user1, response1)
+
+    print("\n=========================================")
+    print("--- Simulation: Second Query (Contextual Follow-up) ---")
+    # The agent should remember 'change' and apply it to a new topic like 'memory'.
+    user2 = "How does the instability of memory relate to constant change?"
+    response2 = agent.process_request(user2)
+    print(f"\n[Final Agent Output]: {response2}")
+    agent.log_interaction(user2, response2)
+
+    print("\n=========================================")
+    print("--- Simulation: New Topic (Testing LTM Recall) ---")
+    # The agent should now recall the 'blue sky' lesson when we discuss deep topics again.
+    user3 = "I feel overwhelmed by vastness; like looking up at a huge blue expanse."
+    response3 = agent.process_request(user3)
+    print(f"\n[Final Agent Output]: {response3}")
+