clementine-agent 1.18.144 → 1.18.146

package/dist/cli/index.js

@@ -463,31 +463,59 @@ function cmdStop() {
         catch { /* ignore */ }
     }
 }
+/**
+ * 1.18.146 — Spawn the dashboard child detached + briefly verify it's
+ * listening on :3030. Used by both `restart` and `update` so the
+ * dashboard reliably comes back after a daemon refresh.
+ *
+ * The dashboard token rotates on each spawn — print the fresh URL so
+ * the user's old browser tab (which would silently 401 on the stale
+ * token) doesn't waste their time.
+ */
+async function relaunchDashboardDetached() {
+    try {
+        const { spawn: spawnProc } = await import('node:child_process');
+        const child = spawnProc('node', [path.join(PACKAGE_ROOT, 'dist/cli/index.js'), 'dashboard'], { detached: true, stdio: 'ignore' });
+        child.unref();
+        // Brief liveness wait — give the child ~3s to bind before we
+        // print the URL. If it never binds, the URL still prints (user
+        // can retry) but we surface the failure in logs.
+        await new Promise(resolve => setTimeout(resolve, 3000));
+        let token = '';
+        try {
+            const tokenPath = path.join(BASE_DIR, '.dashboard-token');
+            if (existsSync(tokenPath))
+                token = readFileSync(tokenPath, 'utf-8').trim();
+        }
+        catch { /* token may not be ready yet */ }
+        if (token) {
+            console.log(`  Dashboard relaunched: http://localhost:3030/?token=${token}`);
+        }
+        else {
+            console.log('  Dashboard relaunched (token not ready — check `clementine status`).');
+        }
+    }
+    catch {
+        console.log('  Could not relaunch dashboard — run: clementine dashboard');
+    }
+}
 async function cmdRestart(options) {
     cmdStop();
-    // Kill ALL dashboard processes (not just PID file — catches orphans)
-    let dashboardWasRunning = false;
+    // Kill ALL dashboard processes (not just PID file — catches orphans).
+    // Restart implies "I want a fresh dashboard too" — always respawn,
+    // not just when the kill check found one. Closes the race where the
+    // dashboard had crashed (or been killed by an earlier `clementine
+    // update`) before restart ran, leaving the user with no dashboard.
     try {
         const { killExistingDashboards } = await import('./dashboard.js');
         const killed = killExistingDashboards();
         if (killed > 0) {
-            dashboardWasRunning = true;
             console.log(`  Stopped ${killed} dashboard process(es).`);
         }
     }
     catch { /* dashboard module may not be available */ }
     await cmdLaunch({ foreground: options.foreground });
-    if (dashboardWasRunning) {
-        try {
-            const { spawn: spawnProc } = await import('node:child_process');
-            const child = spawnProc('node', [path.join(PACKAGE_ROOT, 'dist/cli/index.js'), 'dashboard'], { detached: true, stdio: 'ignore' });
-            child.unref();
-            console.log('  Dashboard relaunched.');
-        }
-        catch {
-            console.log('  Could not relaunch dashboard — run: clementine dashboard');
-        }
-    }
+    await relaunchDashboardDetached();
 }
 function cmdStatus() {
     const DIM = '\x1b[0;90m';
@@ -4262,10 +4290,13 @@ async function cmdUpdate(options) {
         }
     }
     catch { /* no dashboard running */ }
-    // Don't auto-relaunch dashboard during update — it causes duplicate process issues.
-    // The daemon restart below will handle it, or user can run: clementine dashboard
+    // 1.18.146 — `dashboardWasRunning` was previously dropped on the
+    // floor here (the comment said "the daemon restart below will handle
+    // it" — but cmdRestart's own dashboard detection runs after this kill
+    // so it sees zero and never respawns). Now we explicitly remember to
+    // respawn at the end of update if the user had a dashboard up before.
     if (dashboardWasRunning) {
-        console.log(`  Dashboard stopped. Relaunch with: ${DIM}clementine dashboard${RESET}`);
+        console.log(`  ${GREEN}OK${RESET}  Dashboard will relaunch after daemon restart.`);
     }
     // 12. Write update sentinel so the daemon can report what happened
     let commitHash = '';
@@ -4399,6 +4430,14 @@ async function cmdUpdate(options) {
         }
         catch { /* .env read failed */ }
     }
+    // 13.5. Respawn dashboard if it was running before the update.
+    // 1.18.146 — closes the bug where `clementine update restart` left
+    // users with no dashboard because the kill at step 11 above robbed
+    // cmdRestart of its respawn signal. Now we own the respawn here
+    // when we own the kill.
+    if (dashboardWasRunning) {
+        await relaunchDashboardDetached();
+    }
     // 14. Show current version
     console.log();
     if (previousVersion !== 'unknown' && newVersion !== 'unknown' && previousVersion !== newVersion) {

package/dist/tools/brain-tools.d.ts

@@ -31,5 +31,20 @@ export interface BrainIngestFolderResult {
     message: string;
 }
 export declare function ingestBrainRecords(slug: string, records: IngestRecordInput[]): Promise<BrainIngestFolderResult>;
+export interface BrainSaveInput {
+    /** Either a URL (will be fetched) or raw text content. */
+    content: string;
+    /** Optional human-readable title. Inferred from <title> tag for HTML URLs. */
+    title?: string;
+    /** Logical bucket the record belongs to. Default: "chat-saves". */
+    slug?: string;
+    /** Stable id so repeat saves dedupe. Default: hash of content. */
+    externalId?: string;
+    /** Free-form tags carried in frontmatter for later filtering/recall. */
+    tags?: string[];
+}
+export declare function brainSave(input: BrainSaveInput): Promise<BrainIngestFolderResult & {
+    sourceType: 'url' | 'text';
+}>;
 export declare function registerBrainTools(server: McpServer): void;
 //# sourceMappingURL=brain-tools.d.ts.map

package/dist/tools/brain-tools.js

@@ -125,7 +125,120 @@ export async function ingestBrainRecords(slug, records) {
         message,
     };
 }
+// ── brain_save — one-shot ingestion from chat ─────────────────────────
+//
+// 1.18.145 — closes the chat-parity gap on the write side. The user
+// can now say "save this article" or "ingest this URL" and the agent
+// drives the same pipeline the dashboard's Seed tab uses, no manual
+// record assembly required.
+//
+// Accepts either raw text or a URL. URLs are fetched + reasonably
+// extracted (HTML→text via regex strip, JSON/markdown passthrough);
+// for richer extraction the user should still use the dashboard's
+// adapter pipeline (PDF/DOCX/CSV/etc. — they need parsers we don't
+// want to import into every chat session).
+const URL_LIKE = /^https?:\/\//i;
+function looksLikeUrl(s) {
+    return URL_LIKE.test(s.trim());
+}
+async function fetchUrlText(url, timeoutMs = 20_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { 'User-Agent': 'Clementine/brain_save (compatible; +https://github.com/Natebreynolds/Clementine-AI-Assistant)' },
+        });
+        if (!res.ok)
+            throw new Error(`HTTP ${res.status} ${res.statusText}`);
+        const contentType = res.headers.get('content-type') ?? '';
+        const raw = await res.text();
+        if (/json/i.test(contentType)) {
+            return { text: raw, contentType };
+        }
+        if (/html/i.test(contentType) || /^\s*<!DOCTYPE|^\s*<html/i.test(raw)) {
+            // Crude HTML→text. Good enough for "save this article" — anything
+            // fancier (Readability, Mercury) is a dashboard concern.
+            const titleMatch = raw.match(/<title[^>]*>([^<]+)<\/title>/i);
+            const title = titleMatch ? titleMatch[1].trim() : undefined;
+            const text = raw
+                .replace(/<script[\s\S]*?<\/script>/gi, '')
+                .replace(/<style[\s\S]*?<\/style>/gi, '')
+                .replace(/<[^>]+>/g, ' ')
+                .replace(/&nbsp;/g, ' ')
+                .replace(/&amp;/g, '&')
+                .replace(/&lt;/g, '<')
+                .replace(/&gt;/g, '>')
+                .replace(/&quot;/g, '"')
+                .replace(/&#39;/g, "'")
+                .replace(/\s+/g, ' ')
+                .trim();
+            return { text, title, contentType };
+        }
+        // Plaintext, markdown, etc.
+        return { text: raw, contentType };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function brainSave(input) {
+    const slug = sanitizeSlug(input.slug || 'chat-saves');
+    const isUrl = looksLikeUrl(input.content);
+    let text = input.content;
+    let title = input.title;
+    let urlContentType;
+    if (isUrl) {
+        const fetched = await fetchUrlText(input.content);
+        text = fetched.text;
+        title = title || fetched.title || input.content;
+        urlContentType = fetched.contentType;
+    }
+    if (!text || !text.trim()) {
+        throw new Error('brain_save: content is empty after fetch/extract');
+    }
+    // Stable id: caller-provided OR URL-as-id OR sha-style hash of text
+    const externalId = input.externalId
+        || (isUrl ? input.content : fallbackExternalId(slug, 0, text));
+    const metadata = {
+        savedFromChat: true,
+        sourceType: isUrl ? 'url' : 'text',
+    };
+    if (isUrl)
+        metadata.url = input.content;
+    if (urlContentType)
+        metadata.contentType = urlContentType;
+    if (input.tags && input.tags.length)
+        metadata.tags = input.tags;
+    const result = await ingestBrainRecords(slug, [{
+            title: title || 'Untitled',
+            externalId,
+            content: text,
+            metadata,
+        }]);
+    return { ...result, sourceType: isUrl ? 'url' : 'text' };
+}
 export function registerBrainTools(server) {
+    server.tool('brain_save', 'Save a single piece of content (text or URL) to the brain right now. Use when the user says things like "remember this", "save this article", "ingest this URL", "add to memory". Routes through the same distillation pipeline the dashboard\'s Seed tab uses (chunking + LLM summary + vault note + memory index + knowledge graph). For batch ingestion or recurring feeds, see brain_ingest_folder + schedule_skill.', {
+        content: z.string().describe('Either a URL (fetched + text-extracted) or raw text content.'),
+        title: z.string().optional().describe('Optional human-readable title. Inferred from <title> tag for HTML URLs.'),
+        slug: z.string().optional().describe('Logical bucket (folder) the record lands in under 04-Ingest/<slug>/. Default: "chat-saves".'),
+        externalId: z.string().optional().describe('Stable id so repeat saves dedupe (e.g. URL, message id). Default: hash of content.'),
+        tags: z.array(z.string()).optional().describe('Free-form tags persisted in frontmatter for later filtering/recall.'),
+    }, async (input) => {
+        try {
+            const result = await brainSave(input);
+            const where = `04-Ingest/${result.slug}/`;
+            return textResult(`Saved to brain (${result.sourceType}): "${(input.title || input.content).slice(0, 80)}"\n` +
+                `Folder: ${where} · Pipeline: ${result.pipeline.recordsIn} in · ${result.pipeline.recordsWritten} written · ${result.pipeline.recordsSkipped} skipped` +
+                (result.pipeline.recordsFailed > 0 ? ` · ${result.pipeline.recordsFailed} failed` : ''));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error({ err }, 'brain_save: failed');
+            return textResult(`brain_save failed: ${msg}`);
+        }
+    });
     server.tool('brain_ingest_folder', 'Ingest a batch of records into the brain under a named slug. Sends records directly into the distillation pipeline (chunking, LLM summarization, vault note write, memory indexing, knowledge graph write). Use at the end of Connector Feed cron jobs. Safe to re-run — records with the same externalId update the same distilled note.', {
         slug: z.string().describe('Feed slug (matches 04-Ingest/<slug> folder). Lowercase, hyphen-separated.'),
         records: z.array(z.object({

package/dist/tools/mcp-server.js

@@ -31,6 +31,7 @@ import { registerBackgroundTaskTools } from './background-task-tools.js';
 import { registerDecisionReflectionTools } from './decision-reflection-tools.js';
 import { registerBuilderTools } from './builder-tools.js';
 import { registerSkillTools } from './skill-tools.js';
+import { registerScheduleTools } from './schedule-tools.js';
 // ── Server ──────────────────────────────────────────────────────────────
 const serverName = (env['ASSISTANT_NAME'] ?? 'Clementine').toLowerCase() + '-tools';
 const server = new McpServer({ name: serverName, version: '1.0.0' });
@@ -75,6 +76,7 @@ registerBackgroundTaskTools(scopedServer);
 registerDecisionReflectionTools(scopedServer);
 registerBuilderTools(scopedServer);
 registerSkillTools(scopedServer);
+registerScheduleTools(scopedServer);
 // ── Main ────────────────────────────────────────────────────────────────
 async function main() {
     // Initialize memory store and run full sync on startup

package/dist/tools/schedule-tools.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Clementine TypeScript — Schedule MCP tools.
+ *
+ * Thin chat-facing wrappers around src/agent/schedule-registry.ts so
+ * the agent can compose the full automation flow from natural language:
+ *
+ *   user: "scrape Drive every 2 days for AI articles, save to memory"
+ *   agent: 1. create_skill('drive-ai-scraper', { body: '...' })
+ *          2. schedule_skill('drive-ai-scraper', '0 9 *_/2 * *')  (comment elides slash)
+ *
+ * 1.18.145 — closes the chat-parity gap on the automation side. Before
+ * this, the agent could create skills but had no way to schedule them
+ * recurringly without dropping to the dashboard.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerScheduleTools(server: McpServer): void;
+//# sourceMappingURL=schedule-tools.d.ts.map

package/dist/tools/schedule-tools.js

@@ -0,0 +1,105 @@
+/**
+ * Clementine TypeScript — Schedule MCP tools.
+ *
+ * Thin chat-facing wrappers around src/agent/schedule-registry.ts so
+ * the agent can compose the full automation flow from natural language:
+ *
+ *   user: "scrape Drive every 2 days for AI articles, save to memory"
+ *   agent: 1. create_skill('drive-ai-scraper', { body: '...' })
+ *          2. schedule_skill('drive-ai-scraper', '0 9 *_/2 * *')  (comment elides slash)
+ *
+ * 1.18.145 — closes the chat-parity gap on the automation side. Before
+ * this, the agent could create skills but had no way to schedule them
+ * recurringly without dropping to the dashboard.
+ */
+import { z } from 'zod';
+import cron from 'node-cron';
+import { listSchedules, getSchedule, setSchedule, removeSchedule, enableSchedule, } from '../agent/schedule-registry.js';
+import { loadSkillByName } from '../agent/skill-extractor.js';
+import { textResult, logger } from './shared.js';
+export function registerScheduleTools(server) {
+    server.tool('schedule_skill', 'Schedule a skill to run automatically on a cron expression. Pair with create_skill to build "recurring brain feeds" or any other automation from chat. The skill must already exist in the catalog. Idempotent — calling twice for the same skill updates the existing schedule. Use enabled=false to pause without losing the schedule.', {
+        skillName: z.string().describe('The skill slug (must already exist in the catalog — call create_skill first if needed).'),
+        schedule: z.string().describe('Cron expression. Examples: "0 9 * * *" = daily 9am, "0 9 */2 * *" = every 2 days at 9am, "0 */4 * * *" = every 4 hours, "0 7 * * 1-5" = weekdays at 7am.'),
+        enabled: z.boolean().optional().describe('When false, schedule is saved but the runner skips it. Default: true.'),
+        agentSlug: z.string().nullable().optional().describe('Optional: run as a hired agent (e.g. "ross-the-sdr"). Default: null = Clementine.'),
+    }, async ({ skillName, schedule, enabled, agentSlug }) => {
+        // Validate cron expression up-front so the user gets a clear
+        // error before we touch the registry.
+        if (!cron.validate(schedule)) {
+            return textResult(`schedule_skill: "${schedule}" is not a valid cron expression. Try something like "0 9 * * *" (daily 9am).`);
+        }
+        // Validate the skill exists. Without this, the schedule would
+        // silently sit in the registry and the cron scheduler would skip
+        // it on every fire — confusing failure mode.
+        const skill = loadSkillByName(skillName, agentSlug ?? undefined);
+        if (!skill) {
+            return textResult(`schedule_skill: skill "${skillName}" not found${agentSlug ? ` (in agent "${agentSlug}" scope)` : ''}. ` +
+                `Create it first with create_skill, then schedule it.`);
+        }
+        try {
+            const entry = setSchedule(skillName, {
+                schedule,
+                enabled: enabled ?? true,
+                agentSlug: agentSlug ?? null,
+            });
+            logger.info({ skillName, schedule, enabled: entry.enabled, agentSlug: entry.agentSlug }, 'schedule_skill: scheduled');
+            return textResult(`Scheduled "${skillName}" to run on "${schedule}"` +
+                (entry.enabled ? '' : ' (DISABLED — flip enabled:true to start firing)') +
+                `. View on the Tasks page or call list_schedules to confirm.`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            logger.error({ err, skillName }, 'schedule_skill: failed');
+            return textResult(`schedule_skill failed: ${msg}`);
+        }
+    });
+    server.tool('list_schedules', 'List every scheduled skill and its cron expression. Returns the same data the dashboard\'s Tasks page shows for the SKILL-tagged rows.', {}, async () => {
+        try {
+            const entries = listSchedules();
+            if (entries.length === 0) {
+                return textResult('No scheduled skills yet. Use schedule_skill to create one.');
+            }
+            const lines = [`${entries.length} scheduled skill${entries.length === 1 ? '' : 's'}:`];
+            for (const e of entries) {
+                const status = e.enabled ? '✓' : '⏸';
+                const owner = e.agentSlug ? ` (as ${e.agentSlug})` : '';
+                lines.push(`${status} ${e.skillName} — ${e.schedule}${owner}`);
+            }
+            return textResult(lines.join('\n'));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return textResult(`list_schedules failed: ${msg}`);
+        }
+    });
+    server.tool('unschedule_skill', 'Remove a skill\'s schedule entirely. The skill stays in the catalog and can still be run manually or rescheduled later. Use pause_schedule (enabled:false via schedule_skill) for a temporary pause instead.', {
+        skillName: z.string().describe('The skill slug to unschedule.'),
+    }, async ({ skillName }) => {
+        const existing = getSchedule(skillName);
+        if (!existing) {
+            return textResult(`unschedule_skill: "${skillName}" wasn't scheduled — nothing to do.`);
+        }
+        try {
+            removeSchedule(skillName);
+            logger.info({ skillName }, 'unschedule_skill: removed');
+            return textResult(`Unscheduled "${skillName}". The skill stays in the catalog and can be run manually.`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return textResult(`unschedule_skill failed: ${msg}`);
+        }
+    });
+    server.tool('pause_schedule', 'Pause or resume an existing scheduled skill without losing its cron expression. Equivalent to schedule_skill with enabled:false but doesn\'t require re-passing the schedule string.', {
+        skillName: z.string().describe('The skill slug.'),
+        enabled: z.boolean().describe('true = resume firing, false = pause.'),
+    }, async ({ skillName, enabled }) => {
+        const updated = enableSchedule(skillName, enabled);
+        if (!updated) {
+            return textResult(`pause_schedule: "${skillName}" isn't scheduled. Use schedule_skill to create the schedule first.`);
+        }
+        logger.info({ skillName, enabled }, 'pause_schedule: updated');
+        return textResult(`${enabled ? 'Resumed' : 'Paused'} "${skillName}" (${updated.schedule}).`);
+    });
+}
+//# sourceMappingURL=schedule-tools.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clementine-agent",
-  "version": "1.18.144",
+  "version": "1.18.146",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",