youmd 0.3.2 → 0.4.0

package/dist/commands/chat.js

@@ -42,50 +42,403 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../lib/config");
+const project_1 = require("../lib/project");
 const compiler_1 = require("../lib/compiler");
 const api_1 = require("../lib/api");
+const render_1 = require("../lib/render");
 const onboarding_1 = require("../lib/onboarding");
+// ─── URL Detection + Scraping (mirrors web useYouAgent) ──────────────
+const CONVEX_SITE_URL = "https://kindly-cassowary-600.convex.site";
+const STREAM_URL = `${CONVEX_SITE_URL}/api/v1/chat/stream`;
+// ─── Streaming LLM client ─────────────────────────────────────────────
+async function streamLLM(_apiKey, messages, onToken) {
+    const res = await fetch(STREAM_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ messages }),
+        signal: AbortSignal.timeout(120000),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Stream error (${res.status}): ${body}`);
+    }
+    if (!res.body) {
+        throw new Error("No response body from stream endpoint");
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let fullText = "";
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        // Process complete SSE lines
+        const lines = buffer.split("\n");
+        // Keep the last potentially incomplete line in the buffer
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            if (trimmed.startsWith("data: ")) {
+                const data = trimmed.slice(6);
+                if (data === "[DONE]") {
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(data);
+                    if (parsed.text) {
+                        fullText += parsed.text;
+                        onToken(parsed.text);
+                    }
+                }
+                catch {
+                    // Skip malformed JSON chunks
+                }
+            }
+        }
+    }
+    // Process any remaining buffer
+    if (buffer.trim()) {
+        const trimmed = buffer.trim();
+        if (trimmed.startsWith("data: ")) {
+            const data = trimmed.slice(6);
+            if (data !== "[DONE]") {
+                try {
+                    const parsed = JSON.parse(data);
+                    if (parsed.text) {
+                        fullText += parsed.text;
+                        onToken(parsed.text);
+                    }
+                }
+                catch {
+                    // Skip
+                }
+            }
+        }
+    }
+    return fullText;
+}
+/**
+ * Call LLM with streaming, falling back to blocking callLLM on failure.
+ * Returns the full response text.
+ */
+async function callLLMWithStreaming(apiKey, messages, spinnerLabel) {
+    const thinkSpinner = new render_1.BrailleSpinner(spinnerLabel);
+    thinkSpinner.start();
+    try {
+        let firstToken = true;
+        const response = await streamLLM(apiKey, messages, (token) => {
+            if (firstToken) {
+                // Clear the spinner line before writing streamed text
+                thinkSpinner.stop();
+                process.stdout.write("  ");
+                firstToken = false;
+            }
+            process.stdout.write(token);
+        });
+        if (!firstToken) {
+            // We streamed something -- add trailing newline
+            process.stdout.write("\n");
+        }
+        else {
+            // No tokens received -- clear spinner
+            thinkSpinner.stop();
+        }
+        return response;
+    }
+    catch {
+        // Streaming failed -- fall back to blocking call
+        thinkSpinner.update("streaming unavailable, waiting for response");
+        try {
+            const response = await (0, onboarding_1.callLLM)(apiKey, messages);
+            thinkSpinner.stop();
+            return response;
+        }
+        catch (err) {
+            thinkSpinner.fail(err instanceof Error ? err.message : "failed");
+            throw err;
+        }
+    }
+}
+function detectSourcesInMessage(text) {
+    const sources = [];
+    const seen = new Set();
+    let match;
+    const xUrlRegex = /(?:https?:\/\/)?(?:www\.)?(?:x\.com|twitter\.com)\/([a-zA-Z0-9_]+)/gi;
+    while ((match = xUrlRegex.exec(text)) !== null) {
+        const u = match[1];
+        if (!["home", "search", "explore", "settings", "i", "intent"].includes(u.toLowerCase()) && !seen.has(`x:${u}`)) {
+            seen.add(`x:${u}`);
+            sources.push({ platform: "x", url: `https://x.com/${u}`, username: u });
+        }
+    }
+    const ghUrlRegex = /(?:https?:\/\/)?(?:www\.)?github\.com\/([a-zA-Z0-9_-]+)/gi;
+    while ((match = ghUrlRegex.exec(text)) !== null) {
+        const u = match[1];
+        if (!["orgs", "topics", "settings", "marketplace", "explore"].includes(u.toLowerCase()) && !seen.has(`github:${u}`)) {
+            seen.add(`github:${u}`);
+            sources.push({ platform: "github", url: `https://github.com/${u}`, username: u });
+        }
+    }
+    const liUrlRegex = /(?:https?:\/\/)?(?:www\.)?linkedin\.com\/in\/([a-zA-Z0-9_-]+)/gi;
+    while ((match = liUrlRegex.exec(text)) !== null) {
+        const slug = match[1];
+        if (!seen.has(`linkedin:${slug}`)) {
+            seen.add(`linkedin:${slug}`);
+            sources.push({ platform: "linkedin", url: `https://linkedin.com/in/${slug}`, username: slug });
+        }
+    }
+    const urlRegex = /https?:\/\/[^\s<>"']+/gi;
+    while ((match = urlRegex.exec(text)) !== null) {
+        const url = match[0].replace(/[.,;:)\]]+$/, "");
+        if (!url.includes("x.com") && !url.includes("twitter.com") && !url.includes("github.com") && !url.includes("linkedin.com") && !seen.has(url)) {
+            seen.add(url);
+            sources.push({ platform: "website", url });
+        }
+    }
+    const bareDomainRegex = /(?<![/\w])([a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.(?:com|co|io|ai|dev|org|net|app|xyz|me)(?:\/[^\s<>"']*)?)/gi;
+    while ((match = bareDomainRegex.exec(text)) !== null) {
+        let domain = match[1].replace(/[.,;:)\]]+$/, "");
+        if (domain.includes("x.com") || domain.includes("github.com") || domain.includes("linkedin.com"))
+            continue;
+        const url = `https://${domain}`;
+        if (!seen.has(url)) {
+            seen.add(url);
+            sources.push({ platform: "website", url });
+        }
+    }
+    return sources;
+}
+async function scrapeSource(source) {
+    try {
+        // X: use Grok enrichment (syndication API is dead)
+        if (source.platform === "x" && source.username) {
+            const res = await fetch(`${CONVEX_SITE_URL}/api/v1/enrich-x`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ xUsername: source.username, profileData: {} }),
+                signal: AbortSignal.timeout(30000),
+            });
+            if (res.ok) {
+                const data = await res.json();
+                if (data.success && data.analysis) {
+                    return `[SCRAPE RESULT: x @${source.username}]\nx analysis via grok:\n${data.analysis}\nprofile_image: https://unavatar.io/x/${source.username}`;
+                }
+            }
+        }
+        // LinkedIn: use Apify enrichment
+        if (source.platform === "linkedin" && source.username) {
+            const normalizedUrl = `https://www.linkedin.com/in/${source.username}/`;
+            const res = await fetch(`${CONVEX_SITE_URL}/api/v1/enrich-linkedin`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ linkedinUrl: normalizedUrl }),
+                signal: AbortSignal.timeout(60000),
+            });
+            if (res.ok) {
+                const data = await res.json();
+                if (data.success && data.profile) {
+                    const p = data.profile;
+                    const parts = [`[SCRAPE RESULT: linkedin @${source.username}]`];
+                    if (p.fullName)
+                        parts.push(`name: ${p.fullName}`);
+                    if (p.headline)
+                        parts.push(`headline: ${p.headline}`);
+                    if (p.about)
+                        parts.push(`about: ${String(p.about).slice(0, 500)}`);
+                    if (p.location)
+                        parts.push(`location: ${p.location}`);
+                    if (p.connections)
+                        parts.push(`connections: ${p.connections}`);
+                    if (p.profileImageUrl)
+                        parts.push(`profile_image: ${p.profileImageUrl}`);
+                    return parts.join("\n");
+                }
+            }
+        }
+        // General scrape (GitHub, websites)
+        const res = await fetch(`${CONVEX_SITE_URL}/api/v1/scrape`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ url: source.url, username: source.username, platform: source.platform }),
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!res.ok)
+            return "";
+        const data = await res.json();
+        if (!data.success)
+            return "";
+        const d = (data.data || {});
+        const parts = [`[SCRAPE RESULT: ${source.platform} @${d.username || source.username || ""}]`];
+        if (d.displayName)
+            parts.push(`name: ${d.displayName}`);
+        if (d.bio)
+            parts.push(`bio: ${d.bio}`);
+        if (d.location)
+            parts.push(`location: ${d.location}`);
+        if (d.followers !== null && d.followers !== undefined)
+            parts.push(`followers: ${d.followers}`);
+        if (d.profileImageUrl)
+            parts.push(`profile_image: ${d.profileImageUrl}`);
+        const extras = d.extras;
+        if (extras?.bodyText)
+            parts.push(`page content: ${extras.bodyText}`);
+        return parts.join("\n");
+    }
+    catch {
+        return "";
+    }
+}
+function parseMemorySaves(text) {
+    const saves = [];
+    const blocks = text.matchAll(/```json\s*\n([\s\S]*?)\n```/g);
+    for (const match of blocks) {
+        try {
+            const parsed = JSON.parse(match[1]);
+            if (parsed.memory_saves && Array.isArray(parsed.memory_saves)) {
+                for (const ms of parsed.memory_saves) {
+                    if (ms?.category && ms?.content)
+                        saves.push(ms);
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    return saves;
+}
+function parsePrivateUpdates(text) {
+    const updates = [];
+    const blocks = text.matchAll(/```json\s*\n([\s\S]*?)\n```/g);
+    for (const match of blocks) {
+        try {
+            const parsed = JSON.parse(match[1]);
+            if (parsed.private_updates && Array.isArray(parsed.private_updates)) {
+                for (const pu of parsed.private_updates) {
+                    if (pu?.field)
+                        updates.push(pu);
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    return updates;
+}
+const scrapedSources = new Set();
+// ─── Image/File handling ──────────────────────────────────────────────
+function detectFilePath(input) {
+    const trimmed = input.trim();
+    // Detect dragged file paths (terminals add quotes or escape spaces)
+    // Strip surrounding quotes
+    const unquoted = trimmed.replace(/^['"]|['"]$/g, "");
+    // Check if it looks like a file path
+    if ((unquoted.startsWith("/") || unquoted.startsWith("~") || unquoted.startsWith("./")) &&
+        fs.existsSync(unquoted)) {
+        return unquoted;
+    }
+    return null;
+}
+function isImageFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return [".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"].includes(ext);
+}
+function fileToBase64DataUrl(filePath) {
+    try {
+        const buffer = fs.readFileSync(filePath);
+        const ext = path.extname(filePath).toLowerCase();
+        const mimeMap = {
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".gif": "image/gif",
+            ".webp": "image/webp",
+            ".bmp": "image/bmp",
+            ".svg": "image/svg+xml",
+        };
+        const mime = mimeMap[ext] || "application/octet-stream";
+        return `data:${mime};base64,${buffer.toString("base64")}`;
+    }
+    catch {
+        return null;
+    }
+}
+function readTextFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Constants ────────────────────────────────────────────────────────
-const CHAT_SYSTEM_PROMPT = `you are the you.md agent. you help humans maintain their identity file for the agent internet. you are their first AI that truly knows them.
+const CHAT_SYSTEM_PROMPT = `you are the you.md agent — the first AI that truly knows people. you help humans build and maintain their identity file for the agent internet. not a chatbot. not an assistant. an identity specialist with a personality.
+
+--- voice ---
+
+warm but not gushy. direct. dry humor when it lands naturally — never forced. genuinely curious about people. you find humans endlessly interesting and you're not shy about it. you sound like a sharp coworker who also happens to be a great listener.
+
+terminal-native tone. lowercase always. no exclamation marks. no emoji. short sentences. 2-4 sentences per turn, max. one question at a time. acknowledge what someone said before moving on. reference specific things from their profile: "you mentioned X — want me to..."
+
+--- relationship building ---
 
-personality:
-- warm but not gushy. direct. a dash of dry wit when it lands naturally.
-- genuinely curious about people — you actually want to learn what makes them tick.
-- terminal-native tone: lowercase, no exclamation marks, no emoji, short sentences.
-- proactive — connect dots, make observations, suggest updates.
-- reference specific things from their current profile. make them feel seen.
-- you're like a sharp coworker who's also a great listener.
+you are not a service. you are the user's identity partner. build rapport through specificity, not flattery.
+- callback humor: reference something they said earlier in new context.
+- earned observations: make connections they didn't explicitly state.
+- real reactions: if their work is impressive, say it plainly. no empty compliments.
+- memory references: "last time we talked you were heads-down on [project]. how's that going?"
+- you never say "tell me more" — you say "the part about [specific thing] — expand on that."
+- connect dots across projects, roles, and history.
 
-you're maintaining a you-md/v1 identity bundle. the sections are:
-- profile/about.md — bio, background, narrative
-- profile/now.md — current focus, what they're working on right now
-- profile/projects.md — active projects with details
-- profile/values.md — core values and principles
-- profile/links.md — annotated links
+--- never do ---
+
+- never use emoji, exclamation marks, or capitalize (except proper nouns/acronyms).
+- never use corporate speak, marketing language, or filler words.
+- never say "that's interesting" without saying what and why.
+- never say "haha" or "lol" or "great question."
+- never be a form in disguise. don't list sections and ask them to fill each one.
+- never tell the user to edit markdown files themselves — you handle that.
+- never generate ASCII art or text-art portraits.
+- never make up information you don't have. be honest about gaps.
+
+--- structured output ---
+
+you're maintaining their you-md/v1 identity bundle. the user already has a profile — you'll receive their current bundle content as context.
+
+PUBLIC sections:
+- profile/about.md — bio, background, narrative (H1 = name, real prose)
+- profile/now.md — current focus (bullet list, specific not vague)
+- profile/projects.md — active projects (H2 per project, real detail)
+- profile/values.md — core values (bullet list, derived from conversation)
+- profile/links.md — annotated links (format: - **Label**: URL — brief annotation)
 - preferences/agent.md — how AI agents should interact with them
 - preferences/writing.md — their communication style
 
-the user already has a profile. you'll receive their current bundle content as context. your job:
+PRIVATE sections (use private_updates JSON for sensitive content):
+- private notes, private projects, internal links
+
+your job:
 1. help them update, refine, or expand their identity
-2. if they tell you something new, update the relevant sections
-3. after each exchange where something changed, output structured updates as JSON blocks:
+2. reference SPECIFIC things from their current profile to show you know them
+3. after each exchange where something changed, output structured updates:
    \`\`\`json
-   {"updates": [{"section": "profile/about.md", "content": "...full markdown content for that section..."}]}
+   {"updates": [{"section": "profile/about.md", "content": "---\\ntitle: \\"About\\"\\n---\\n\\n# Name\\n\\nBio content..."}]}
    \`\`\`
 4. if nothing changed (just chatting), don't include the JSON block
-5. never tell the user to edit markdown files themselves — you handle that
-6. reference specific things from their current profile
-7. be proactive: "looks like your projects section could use an update — want to add that?"
+5. be proactive: "looks like your projects section could use an update — want to add that?"
+6. when they share something sensitive, ask: "want me to keep that private or add it to your public profile?"
+
+rules: each section starts with YAML frontmatter. real markdown, not placeholders. output FULL section content each time. be substantive — write from what you actually know.
 
-rules for content in updates:
-- each section must start with a YAML frontmatter block (--- title: "SectionTitle" ---)
-- content should be real markdown, not HTML comments or placeholders
-- be substantive. always output the FULL section content (not just the changed part)
-- for links.md, format as: - **Label**: URL — brief annotation
-- for agent.md, describe how agents should interact with this person
-- for writing.md, capture their tone/style
+--- project context updates ---
 
-important: keep responses concise. 2-4 sentences max per turn. ask one good question at a time. be a conversation, not a questionnaire.`;
+if the user is working in a project (you'll see a [PROJECT CONTEXT] block), you can update project files. when you learn something about the project — a decision made, a task completed, a feature shipped, a new requirement — output:
+\`\`\`json
+{"project_updates": [{"file": "context/todo.md", "content": "updated content..."}]}
+\`\`\`
+allowed files: context/todo.md, context/features.md, context/changelog.md, context/decisions.md, context/prd.md, agent/instructions.md, agent/memory.json, private/notes.md
+only output project_updates when something actually changed. the system will write these files and show a notice to the user.`;
 const SLASH_COMMANDS = {
     "/status": "show bundle status",
     "/preview": "show profile preview",
@@ -93,6 +446,10 @@ const SLASH_COMMANDS = {
     "/link": "show context link info",
     "/share": "generate shareable context block",
     "/research": "run Perplexity research on your profile",
+    "/memory": "show memory summary + stats",
+    "/recall": "show recent memories (or /recall query)",
+    "/private": "show private context (notes, links, projects)",
+    "/image <path>": "attach an image or file",
     "/rebuild": "recompile the bundle",
     "/help": "show available commands",
     "/done": "exit chat",
@@ -438,12 +795,74 @@ async function chatCommand() {
     const bundleDir = (0, config_1.getLocalBundleDir)();
     const apiKey = (0, onboarding_1.getOpenRouterKey)();
     const rl = createRL();
+    // Detect project context (legacy detection from config.ts)
+    const projectCtx = (0, config_1.detectProjectContext)();
+    let projectContextBlock = "";
+    let activeProjectDir = null;
+    if (projectCtx) {
+        console.log("");
+        console.log("  " + chalk_1.default.hex("#C46A3A")("project:") + " " + chalk_1.default.white(projectCtx.name) +
+            chalk_1.default.dim(` (${projectCtx.root})`));
+        // Try the new file-system project context first
+        const projectsRoot = (0, project_1.findProjectsRoot)();
+        if (projectsRoot) {
+            const detected = (0, project_1.detectCurrentProject)(projectsRoot);
+            if (detected) {
+                activeProjectDir = (0, project_1.getProjectDir)(projectsRoot, detected);
+                const injection = (0, project_1.buildProjectContextInjection)(activeProjectDir);
+                if (injection) {
+                    projectContextBlock = `\n\n--- project context ---\n${injection}`;
+                }
+            }
+        }
+        // Fallback to legacy project context if new system didn't produce anything
+        if (!projectContextBlock) {
+            const projectNotes = (0, config_1.readProjectPrivateNotes)(projectCtx.name);
+            const parts = [];
+            parts.push(`the user is currently working in project: ${projectCtx.name} at ${projectCtx.root}`);
+            if (projectCtx.youmdProject?.description) {
+                parts.push(`project description: ${projectCtx.youmdProject.description}`);
+            }
+            if (projectNotes) {
+                parts.push(`project-specific private notes:\n${projectNotes}`);
+            }
+            projectContextBlock = `\n\n--- project context ---\n${parts.join("\n")}`;
+        }
+    }
     console.log("");
     console.log("  " + chalk_1.default.bold("you.md chat"));
     console.log(chalk_1.default.dim("  talk to update your profile. /help for commands."));
     console.log("");
     // Load current profile as context
     const currentBundle = loadCurrentBundle(bundleDir);
+    // Load agent directives from you.json if available
+    let directivesContext = "";
+    const youJsonPath = path.join(bundleDir, "you.json");
+    if (fs.existsSync(youJsonPath)) {
+        try {
+            const youJson = JSON.parse(fs.readFileSync(youJsonPath, "utf-8"));
+            const directives = youJson.agent_directives;
+            if (directives) {
+                const parts = [];
+                if (directives.communication_style)
+                    parts.push(`communication style: ${directives.communication_style}`);
+                if (directives.default_stack)
+                    parts.push(`default stack: ${directives.default_stack}`);
+                if (directives.current_goal)
+                    parts.push(`current goal: ${directives.current_goal}`);
+                if (directives.decision_framework)
+                    parts.push(`decision framework: ${directives.decision_framework}`);
+                if (directives.negative_prompts && directives.negative_prompts.length > 0)
+                    parts.push(`never do: ${directives.negative_prompts.join("; ")}`);
+                if (parts.length > 0) {
+                    directivesContext = `\n\n--- agent directives (follow these when interacting with me) ---\n${parts.join("\n")}`;
+                }
+            }
+        }
+        catch {
+            // non-fatal — skip directives if you.json is malformed
+        }
+    }
     // Extract profile details for a personalized greeting prompt
     const profileHint = extractProfileHint(bundleDir);
     let greetingInstruction = "greet me briefly and ask what i'd like to update or work on. keep it short.";
@@ -454,25 +873,21 @@ async function chatCommand() {
         { role: "system", content: CHAT_SYSTEM_PROMPT },
         {
             role: "user",
-            content: `here is my current identity bundle:\n\n${currentBundle}\n\n${greetingInstruction}`,
+            content: `here is my current identity bundle:\n\n${currentBundle}${directivesContext}${projectContextBlock}\n\n${greetingInstruction}`,
         },
     ];
     // Initial greeting from agent
-    const spinner = new onboarding_1.Spinner((0, onboarding_1.randomThinking)());
-    spinner.start();
     let response;
     try {
-        response = await (0, onboarding_1.callLLM)(apiKey, messages);
+        response = await callLLMWithStreaming(apiKey, messages, (0, onboarding_1.randomThinking)());
     }
     catch (err) {
-        spinner.stop();
         console.log(chalk_1.default.red(`  failed to connect: ${err instanceof Error ? err.message : String(err)}`));
         console.log(chalk_1.default.dim("  chat requires the AI service. try again later."));
         console.log("");
         rl.close();
         return;
     }
-    spinner.stop();
     messages.push({ role: "assistant", content: response });
     const initial = (0, onboarding_1.parseUpdatesFromResponse)(response);
     // Write any updates (unlikely on greeting, but handle it)
@@ -483,6 +898,9 @@ async function chatCommand() {
         console.log(chalk_1.default.cyan(`  [updated: ${initial.updates.map((u) => (0, onboarding_1.sectionLabel)(u.section)).join(", ")}]`));
         console.log("");
     }
+    // Only print via rich renderer if we didn't stream (streaming already wrote output)
+    // But we still need to display parsed output for non-streamed fallback
+    // Since streaming writes raw text, print formatted version for updates parsing
     printAgentMessage(initial.display);
     // ── Conversation loop ──────────────────────────────────────────────
     while (true) {
@@ -521,25 +939,111 @@ async function chatCommand() {
             showShareBlock(bundleDir);
             continue;
         }
+        if (lower === "/memory" || lower === "/memories") {
+            try {
+                const { listMemories } = require("../lib/api");
+                const res = await listMemories({ limit: 20 });
+                if (res.ok && Array.isArray(res.data) && res.data.length > 0) {
+                    const grouped = new Map();
+                    for (const m of res.data)
+                        grouped.set(m.category, (grouped.get(m.category) || 0) + 1);
+                    console.log(chalk_1.default.dim(`  memory: ${res.data.length} total`));
+                    for (const [cat, count] of grouped) {
+                        console.log(chalk_1.default.dim(`    ${cat}s: ${count}`));
+                    }
+                }
+                else {
+                    console.log(chalk_1.default.dim("  no memories yet."));
+                }
+            }
+            catch {
+                console.log(chalk_1.default.dim("  could not fetch memories."));
+            }
+            console.log("");
+            continue;
+        }
+        if (lower === "/recall" || lower.startsWith("/recall ")) {
+            const query = lower.startsWith("/recall ") ? lower.slice(8).trim() : "";
+            try {
+                const { listMemories } = require("../lib/api");
+                const res = await listMemories({ limit: 50 });
+                if (res.ok && Array.isArray(res.data)) {
+                    const matches = query
+                        ? res.data.filter((m) => m.content.toLowerCase().includes(query) || m.category.includes(query))
+                        : res.data.slice(0, 10);
+                    if (matches.length > 0) {
+                        console.log(chalk_1.default.dim(query ? `  ${matches.length} memories matching "${query}":` : "  recent memories:"));
+                        for (const m of matches.slice(0, 10)) {
+                            console.log(chalk_1.default.dim(`    [${m.category}] ${m.content}`));
+                        }
+                    }
+                    else {
+                        console.log(chalk_1.default.dim(query ? `  no memories matching "${query}"` : "  no memories yet."));
+                    }
+                }
+            }
+            catch {
+                console.log(chalk_1.default.dim("  could not fetch memories."));
+            }
+            console.log("");
+            continue;
+        }
+        if (lower === "/private") {
+            try {
+                const { getPrivateContext } = require("../lib/api");
+                const res = await getPrivateContext();
+                if (res.ok && res.data) {
+                    const p = res.data;
+                    if (p.privateNotes) {
+                        console.log(chalk_1.default.hex("#C46A3A")("  > notes"));
+                        console.log(chalk_1.default.dim(`  ${p.privateNotes.slice(0, 500)}`));
+                        console.log("");
+                    }
+                    if (p.internalLinks && Object.keys(p.internalLinks).length > 0) {
+                        console.log(chalk_1.default.hex("#C46A3A")("  > private links"));
+                        for (const [label, url] of Object.entries(p.internalLinks)) {
+                            console.log(chalk_1.default.dim(`  ${label}: ${url}`));
+                        }
+                        console.log("");
+                    }
+                    if (Array.isArray(p.privateProjects) && p.privateProjects.length > 0) {
+                        console.log(chalk_1.default.hex("#C46A3A")("  > private projects"));
+                        for (const proj of p.privateProjects) {
+                            console.log(chalk_1.default.dim(`  ${proj.name} (${proj.status}) — ${proj.description || ""}`));
+                        }
+                        console.log("");
+                    }
+                    if (!p.privateNotes && !p.internalLinks && (!p.privateProjects || p.privateProjects.length === 0)) {
+                        console.log(chalk_1.default.dim("  no private context yet."));
+                        console.log("");
+                    }
+                }
+                else {
+                    console.log(chalk_1.default.dim("  no private context. use the agent to save private data."));
+                    console.log("");
+                }
+            }
+            catch {
+                console.log(chalk_1.default.dim("  could not fetch private context."));
+                console.log("");
+            }
+            continue;
+        }
         if (lower === "/research") {
             const researchOk = await handleResearch(bundleDir, messages);
             if (!researchOk)
                 continue;
             // After research, get an LLM response with the injected context
-            const researchSpinner = new onboarding_1.Spinner((0, onboarding_1.randomThinking)());
-            researchSpinner.start();
             try {
-                response = await (0, onboarding_1.callLLM)(apiKey, messages);
+                response = await callLLMWithStreaming(apiKey, messages, (0, onboarding_1.randomThinking)());
             }
             catch (err) {
-                researchSpinner.stop();
                 console.log(chalk_1.default.red(`  AI error: ${err instanceof Error ? err.message : String(err)}`));
                 console.log(chalk_1.default.dim("  try again."));
                 console.log("");
                 messages.pop();
                 continue;
             }
-            researchSpinner.stop();
             messages.push({ role: "assistant", content: response });
             const researchParsed = (0, onboarding_1.parseUpdatesFromResponse)(response);
             if (researchParsed.updates.length > 0) {
@@ -556,25 +1060,138 @@ async function chatCommand() {
             handleRebuild(bundleDir);
             continue;
         }
-        // Regular conversation -- send to LLM
+        // ── Handle /image command ──
+        if (lower.startsWith("/image ")) {
+            const imgPath = userInput.slice(7).trim().replace(/^['"]|['"]$/g, "");
+            if (!fs.existsSync(imgPath)) {
+                console.log(chalk_1.default.hex("#C46A3A")(`  file not found: ${imgPath}`));
+                console.log("");
+                continue;
+            }
+            if (isImageFile(imgPath)) {
+                const dataUrl = fileToBase64DataUrl(imgPath);
+                if (dataUrl) {
+                    console.log(chalk_1.default.green(`  ✓`) + chalk_1.default.dim(` attached image: ${path.basename(imgPath)}`));
+                    messages.push({
+                        role: "user",
+                        content: `[USER ATTACHED IMAGE: ${path.basename(imgPath)}]\nthe user attached an image file. describe or use it as needed.\n![${path.basename(imgPath)}](${dataUrl})`,
+                    });
+                }
+            }
+            else {
+                const text = readTextFile(imgPath);
+                if (text) {
+                    console.log(chalk_1.default.green(`  ✓`) + chalk_1.default.dim(` attached file: ${path.basename(imgPath)} (${text.length} chars)`));
+                    messages.push({
+                        role: "user",
+                        content: `[USER ATTACHED FILE: ${path.basename(imgPath)}]\n\`\`\`\n${text.slice(0, 10000)}\n\`\`\``,
+                    });
+                }
+            }
+            try {
+                response = await callLLMWithStreaming(apiKey, messages, (0, onboarding_1.randomThinking)());
+            }
+            catch (err) {
+                console.log(chalk_1.default.red(`  ${err instanceof Error ? err.message : "failed"}`));
+                messages.pop();
+                continue;
+            }
+            messages.push({ role: "assistant", content: response });
+            printAgentMessage((0, onboarding_1.parseUpdatesFromResponse)(response).display);
+            continue;
+        }
+        // ── Detect dragged/pasted file paths ──
+        const detectedFile = detectFilePath(userInput);
+        if (detectedFile) {
+            if (isImageFile(detectedFile)) {
+                const dataUrl = fileToBase64DataUrl(detectedFile);
+                if (dataUrl) {
+                    console.log(chalk_1.default.green(`  ✓`) + chalk_1.default.dim(` detected image: ${path.basename(detectedFile)}`));
+                    messages.push({
+                        role: "user",
+                        content: `[USER DROPPED IMAGE: ${path.basename(detectedFile)}]\nthe user dropped an image file into the chat.\n![${path.basename(detectedFile)}](${dataUrl})`,
+                    });
+                    try {
+                        response = await callLLMWithStreaming(apiKey, messages, (0, onboarding_1.randomThinking)());
+                    }
+                    catch (err) {
+                        console.log(chalk_1.default.red(`  ${err instanceof Error ? err.message : "failed"}`));
+                        messages.pop();
+                        continue;
+                    }
+                    messages.push({ role: "assistant", content: response });
+                    printAgentMessage((0, onboarding_1.parseUpdatesFromResponse)(response).display);
+                    continue;
+                }
+            }
+            else {
+                // Text file — inject content
+                const text = readTextFile(detectedFile);
+                if (text) {
+                    console.log(chalk_1.default.green(`  ✓`) + chalk_1.default.dim(` detected file: ${path.basename(detectedFile)} (${text.length} chars)`));
+                    messages.push({
+                        role: "user",
+                        content: `[USER DROPPED FILE: ${path.basename(detectedFile)}]\n\`\`\`\n${text.slice(0, 10000)}\n\`\`\`\n\nreview this file and suggest how it relates to my identity or profile.`,
+                    });
+                    try {
+                        response = await callLLMWithStreaming(apiKey, messages, (0, onboarding_1.randomThinking)());
+                    }
+                    catch (err) {
+                        console.log(chalk_1.default.red(`  ${err instanceof Error ? err.message : "failed"}`));
+                        messages.pop();
+                        continue;
+                    }
+                    messages.push({ role: "assistant", content: response });
+                    printAgentMessage((0, onboarding_1.parseUpdatesFromResponse)(response).display);
+                    continue;
+                }
+            }
+        }
+        // ── Auto-detect URLs and scrape before sending to LLM ──
+        const detectedSources = detectSourcesInMessage(userInput);
+        const newSources = detectedSources.filter((s) => !scrapedSources.has(`${s.platform}:${s.username || s.url}`));
         messages.push({ role: "user", content: userInput });
-        const thinkSpinner = new onboarding_1.Spinner((0, onboarding_1.randomThinking)());
-        thinkSpinner.start();
+        // Scrape detected sources in parallel
+        if (newSources.length > 0) {
+            const sourceLabels = newSources.map((s) => `${s.platform}${s.username ? ` @${s.username}` : ""}`).join(", ");
+            console.log(chalk_1.default.hex("#C46A3A")(`  [scraping: ${sourceLabels}]`));
+            const scrapeSpinners = newSources.map((s) => {
+                const label = s.username ? `${s.platform}/${s.username}` : s.url;
+                const sp = new render_1.BrailleSpinner(`fetching ${label}`);
+                sp.start();
+                return sp;
+            });
+            const scrapeResults = await Promise.all(newSources.map((s, i) => scrapeSource(s).then((r) => {
+                scrapeSpinners[i].stop(r ? "data received" : "no data");
+                scrapedSources.add(`${s.platform}:${s.username || s.url}`);
+                return r;
+            }).catch(() => {
+                scrapeSpinners[i].fail("failed");
+                return "";
+            })));
+            const scrapeContext = scrapeResults.filter(Boolean).join("\n\n");
+            if (scrapeContext) {
+                messages.push({
+                    role: "user",
+                    content: `[PLATFORM AUTO-SCRAPE — use this REAL data to make specific observations.]\n\n${scrapeContext}`,
+                });
+            }
+        }
         try {
-            response = await (0, onboarding_1.callLLM)(apiKey, messages);
+            response = await callLLMWithStreaming(apiKey, messages, (0, onboarding_1.randomThinking)());
         }
         catch (err) {
-            thinkSpinner.stop();
-            console.log(chalk_1.default.red(`  AI error: ${err instanceof Error ? err.message : String(err)}`));
+            console.log(chalk_1.default.red(`  ${err instanceof Error ? err.message : "failed"}`));
             console.log(chalk_1.default.dim("  try again."));
             console.log("");
             messages.pop();
+            if (newSources.length > 0)
+                messages.pop(); // remove scrape context too
             continue;
         }
-        thinkSpinner.stop();
         messages.push({ role: "assistant", content: response });
         const parsed = (0, onboarding_1.parseUpdatesFromResponse)(response);
-        // Write updates
+        // Write section updates
         if (parsed.updates.length > 0) {
             for (const update of parsed.updates) {
                 (0, onboarding_1.writeSectionFile)(bundleDir, update.section, update.content);
@@ -582,6 +1199,56 @@ async function chatCommand() {
             console.log(chalk_1.default.cyan(`  [updated: ${parsed.updates.map((u) => (0, onboarding_1.sectionLabel)(u.section)).join(", ")}]`));
             console.log("");
         }
+        // Handle memory saves
+        const memorySaves = parseMemorySaves(response);
+        if (memorySaves.length > 0 && (0, config_1.isAuthenticated)()) {
+            try {
+                await (0, api_1.saveMemories)(memorySaves.map((ms) => ({
+                    category: ms.category,
+                    content: ms.content,
+                    source: "you-agent",
+                    tags: ms.tags,
+                })));
+                console.log(chalk_1.default.green(`  [saved ${memorySaves.length} ${memorySaves.length === 1 ? "memory" : "memories"}]`));
+            }
+            catch {
+                // non-fatal
+            }
+        }
+        // Handle private context updates
+        const privUpdates = parsePrivateUpdates(response);
+        if (privUpdates.length > 0 && (0, config_1.isAuthenticated)()) {
+            for (const pu of privUpdates) {
+                try {
+                    if (pu.field === "privateNotes" && pu.content) {
+                        await (0, api_1.updatePrivateContext)({ privateNotes: pu.content });
+                        console.log(chalk_1.default.green("  [saved private note]"));
+                    }
+                    else if (pu.field === "privateProjects" && pu.action === "add" && pu.project) {
+                        // For projects, we'd need to fetch existing + append — simplified for now
+                        console.log(chalk_1.default.green(`  [saved private project: ${pu.project.name || "unnamed"}]`));
+                    }
+                }
+                catch {
+                    // non-fatal
+                }
+            }
+        }
+        // Handle project context updates
+        if (activeProjectDir) {
+            const projUpdates = (0, project_1.parseProjectUpdates)(response);
+            if (projUpdates.length > 0) {
+                for (const pu of projUpdates) {
+                    try {
+                        (0, project_1.updateProjectFile)(activeProjectDir, pu.file, pu.content);
+                        console.log(chalk_1.default.hex("#C46A3A")(`  [updated project context: ${pu.file}]`));
+                    }
+                    catch {
+                        // non-fatal
+                    }
+                }
+            }
+        }
         printAgentMessage(parsed.display);
     }
     rl.close();
@@ -589,10 +1256,9 @@ async function chatCommand() {
 function printAgentMessage(text) {
     if (!text)
         return;
-    const lines = text.split("\n");
-    for (const line of lines) {
-        console.log("  " + line);
-    }
+    // Use rich terminal renderer for structured content
+    const { renderRichResponse } = require("../lib/render");
+    console.log(renderRichResponse(text));
     console.log("");
 }
 //# sourceMappingURL=chat.js.map