clementine-agent 1.18.144 → 1.18.145

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.145",
   "description": "Clementine — Personal AI Assistant (TypeScript)",
   "type": "module",
   "main": "dist/index.js",