clementine-agent 1.18.104 → 1.18.105

package/dist/agent/draft-store.d.ts

@@ -0,0 +1,57 @@
+/**
+ * PRD §11 Phase 5b / 1.18.105 — Draft store for cron tasks.
+ *
+ * Drafts live alongside CRON.md (the published source of truth) but in a
+ * separate per-task JSON sidecar at ~/.clementine/cron-drafts/<safe>.json.
+ * Schedule firing always reads CRON.md, so a draft never accidentally
+ * goes live until the user clicks Publish.
+ *
+ * Why a sidecar instead of editing CRON.md and gating with frontmatter:
+ * - One CRON.md edit = many tasks affected. Drafts are per-task by design.
+ * - Sidecars survive even if CRON.md gets rewritten (e.g. by an agent).
+ * - The published-vs-draft diff is a clean two-document compare.
+ *
+ * Tradeoff: a draft can become "orphaned" if its base task gets renamed.
+ * We detect this via basedOnName and surface a banner in the editor when
+ * we can't find the published peer. Manual cleanup via DELETE /api/cron/
+ * :name/draft.
+ */
+import type { CronJobDefinition } from '../types.js';
+/** Stable hash of a job def — used to detect drift between when the draft
+ *  was created and the current published version. If the published task
+ *  changed under the draft (someone else edited it), we surface a warning
+ *  and ask the user if they want to rebase. */
+export declare function hashJobDef(def: CronJobDefinition): string;
+export interface DraftRecord {
+    /** Task name this draft belongs to. Matches the published task's name
+     *  (renames detach the draft — the user must republish to a new name). */
+    name: string;
+    /** Full job def the user is staging. Same shape as CronJobDefinition. */
+    draft: CronJobDefinition;
+    /** ISO timestamp of last save. */
+    savedAt: string;
+    /** Author marker. 'dashboard' for UI saves; future channels may add their
+     *  own values. */
+    changedBy: string;
+    /** Hash of the published def at the time the draft was first created.
+     *  If the live published def hashes to something different now, the
+     *  draft is "rebased" — the editor surfaces a banner. */
+    basedOnPublishedHash: string | null;
+}
+export declare function getDraft(name: string): DraftRecord | null;
+export declare function saveDraft(record: DraftRecord): void;
+export declare function deleteDraft(name: string): boolean;
+export declare function listDraftNames(): string[];
+/** Compute draft state vs current published def. The badge in the editor
+ *  reads this directly — four states matching the n8n flow:
+ *    none           = no draft sidecar, task is on its published version
+ *    draft          = draft exists, no published peer (new task being created)
+ *    ready          = draft + published peer; draft != published
+ *    up_to_date     = draft + published peer; draft hashes match published
+ *    rebase_needed  = draft + published peer; published has drifted since draft was created
+ */
+export type DraftBadgeState = 'none' | 'draft' | 'ready' | 'up_to_date' | 'rebase_needed';
+export declare function computeBadgeState(name: string, publishedDef: CronJobDefinition | null): DraftBadgeState;
+/** Test-only: where we read/write drafts. Tests use a clean tmpdir. */
+export declare function _draftDirForTests(): string;
+//# sourceMappingURL=draft-store.d.ts.map

package/dist/agent/draft-store.js

@@ -0,0 +1,113 @@
+/**
+ * PRD §11 Phase 5b / 1.18.105 — Draft store for cron tasks.
+ *
+ * Drafts live alongside CRON.md (the published source of truth) but in a
+ * separate per-task JSON sidecar at ~/.clementine/cron-drafts/<safe>.json.
+ * Schedule firing always reads CRON.md, so a draft never accidentally
+ * goes live until the user clicks Publish.
+ *
+ * Why a sidecar instead of editing CRON.md and gating with frontmatter:
+ * - One CRON.md edit = many tasks affected. Drafts are per-task by design.
+ * - Sidecars survive even if CRON.md gets rewritten (e.g. by an agent).
+ * - The published-vs-draft diff is a clean two-document compare.
+ *
+ * Tradeoff: a draft can become "orphaned" if its base task gets renamed.
+ * We detect this via basedOnName and surface a banner in the editor when
+ * we can't find the published peer. Manual cleanup via DELETE /api/cron/
+ * :name/draft.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+/** Read BASE_DIR fresh on every call so tests can swap CLEMENTINE_HOME
+ *  per-test without the module cache sticking the value at import time. */
+function draftDir() {
+    const base = process.env.CLEMENTINE_HOME || path.join(os.homedir(), '.clementine');
+    return path.join(base, 'cron-drafts');
+}
+function safeName(name) {
+    // Mirror the convention used by CronRunLog.runs/<safe>.jsonl so users
+    // can grep for related files easily.
+    return String(name).replace(/[^a-zA-Z0-9_:-]/g, '_').slice(0, 128);
+}
+function draftPath(name) {
+    return path.join(draftDir(), safeName(name) + '.json');
+}
+/** Stable hash of a job def — used to detect drift between when the draft
+ *  was created and the current published version. If the published task
+ *  changed under the draft (someone else edited it), we surface a warning
+ *  and ask the user if they want to rebase. */
+export function hashJobDef(def) {
+    const canonical = JSON.stringify(def, Object.keys(def).sort());
+    return createHash('sha256').update(canonical).digest('hex').slice(0, 16);
+}
+export function getDraft(name) {
+    const file = draftPath(name);
+    if (!existsSync(file))
+        return null;
+    try {
+        const raw = readFileSync(file, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveDraft(record) {
+    if (!record.name)
+        throw new Error('draft.name is required');
+    if (!record.draft || typeof record.draft !== 'object')
+        throw new Error('draft.draft (job def) is required');
+    mkdirSync(draftDir(), { recursive: true });
+    const file = draftPath(record.name);
+    writeFileSync(file, JSON.stringify(record, null, 2) + '\n');
+}
+export function deleteDraft(name) {
+    const file = draftPath(name);
+    if (!existsSync(file))
+        return false;
+    try {
+        unlinkSync(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function listDraftNames() {
+    const dir = draftDir();
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir)
+            .filter((f) => f.endsWith('.json'))
+            .map((f) => f.replace(/\.json$/, ''));
+    }
+    catch {
+        return [];
+    }
+}
+export function computeBadgeState(name, publishedDef) {
+    const d = getDraft(name);
+    if (!d)
+        return 'none';
+    if (!publishedDef)
+        return 'draft';
+    const publishedHash = hashJobDef(publishedDef);
+    const draftHash = hashJobDef(d.draft);
+    if (publishedHash === draftHash)
+        return 'up_to_date';
+    // Drift detection: if the draft was based on a published version we no
+    // longer recognise, surface "rebase needed". This covers two scenarios:
+    // (a) someone else edited the published def, (b) the user published
+    // through a different surface and forgot to discard the draft.
+    if (d.basedOnPublishedHash && d.basedOnPublishedHash !== publishedHash)
+        return 'rebase_needed';
+    return 'ready';
+}
+/** Test-only: where we read/write drafts. Tests use a clean tmpdir. */
+export function _draftDirForTests() {
+    return draftDir();
+}
+//# sourceMappingURL=draft-store.js.map

package/dist/cli/dashboard.js

@@ -4600,6 +4600,156 @@ export async function cmdDashboard(opts) {
     // tasks should pay the small per-tool overhead of curl-on-every-event)
     // and the installer refuses to overwrite a settings.local.json that
     // wasn't created by us.
+    // ── PRD §11 Phase 5b / 1.18.105: Draft / Publish endpoints ────────
+    // Tasks support per-task draft sidecars at ~/.clementine/cron-drafts/.
+    // The schedule fires off CRON.md only — drafts never go live until
+    // POST /publish promotes them. Five endpoints cover the n8n-style flow:
+    //   GET /api/cron/:job/draft       — current draft + badge state
+    //   POST /api/cron/:job/draft      — save/replace the draft
+    //   POST /api/cron/:job/publish    — promote draft to CRON.md
+    //   DELETE /api/cron/:job/draft    — discard the draft
+    //   GET /api/cron/drafts           — list all drafted task names
+    app.get('/api/cron/drafts', async (_req, res) => {
+        try {
+            const { listDraftNames } = await import('../agent/draft-store.js');
+            res.json({ ok: true, names: listDraftNames() });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
+    app.get('/api/cron/:job/draft', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job required' });
+                return;
+            }
+            const { parseCronJobs } = await import('../gateway/cron-scheduler.js');
+            const { getDraft, computeBadgeState } = await import('../agent/draft-store.js');
+            const draft = getDraft(jobName);
+            const published = parseCronJobs().find((j) => String(j.name).toLowerCase() === jobName.toLowerCase()) ?? null;
+            const badge = computeBadgeState(jobName, published);
+            res.json({ ok: true, draft, published, badge });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
+    app.post('/api/cron/:job/draft', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job required' });
+                return;
+            }
+            const body = (req.body ?? {});
+            const draftDef = body.draft;
+            if (!draftDef || typeof draftDef !== 'object') {
+                res.status(400).json({ ok: false, error: 'draft (job def) required in body' });
+                return;
+            }
+            // Force the draft's name to match the URL param so a stale UI can't
+            // retarget. Mostly defensive — the editor wouldn't call here with a
+            // mismatched name, but be paranoid.
+            draftDef.name = jobName;
+            const { parseCronJobs } = await import('../gateway/cron-scheduler.js');
+            const { saveDraft, hashJobDef } = await import('../agent/draft-store.js');
+            const published = parseCronJobs().find((j) => String(j.name).toLowerCase() === jobName.toLowerCase()) ?? null;
+            saveDraft({
+                name: jobName,
+                draft: draftDef,
+                savedAt: new Date().toISOString(),
+                changedBy: typeof body.changedBy === 'string' ? body.changedBy : 'dashboard',
+                basedOnPublishedHash: published ? hashJobDef(published) : null,
+            });
+            res.json({ ok: true, message: published ? 'Draft saved.' : 'Draft saved (no published version yet — Publish to make it live).' });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
+    app.delete('/api/cron/:job/draft', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job required' });
+                return;
+            }
+            const { deleteDraft } = await import('../agent/draft-store.js');
+            const removed = deleteDraft(jobName);
+            res.json({ ok: true, removed, message: removed ? 'Draft discarded.' : 'No draft to discard.' });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
+    app.post('/api/cron/:job/publish', async (req, res) => {
+        try {
+            const jobName = req.params.job;
+            if (!jobName) {
+                res.status(400).json({ ok: false, error: 'job required' });
+                return;
+            }
+            const { getDraft, deleteDraft } = await import('../agent/draft-store.js');
+            const record = getDraft(jobName);
+            if (!record) {
+                res.status(404).json({ ok: false, error: `No draft for "${jobName}". Save changes as a draft first.` });
+                return;
+            }
+            // Promote: write the draft def into CRON.md by re-using the
+            // dashboard's existing readCronFileAt / writeCronFileAt helpers
+            // (defined alongside POST /api/cron). Find the matching job entry
+            // and overwrite in place; if no match, append.
+            try {
+                // Agent-scoped tasks ("<agent>:<jobname>") live in their own
+                // agents/<agent>/CRON.md. Detect via the slug prefix to pick the
+                // right file.
+                const draftDef = record.draft;
+                let targetFile = CRON_FILE;
+                const slugMatch = jobName.match(/^([a-z0-9_-]+):(.+)$/i);
+                if (draftDef.agent || slugMatch) {
+                    const slug = String(draftDef.agent ?? slugMatch?.[1] ?? '');
+                    if (slug && slug !== 'clementine') {
+                        targetFile = path.join(VAULT_DIR, '00-System', 'agents', slug, 'CRON.md');
+                    }
+                }
+                const { parsed, jobs } = readCronFileAt(targetFile);
+                const idx = jobs.findIndex((j) => String(j.name ?? '').toLowerCase() === jobName.toLowerCase());
+                // Strip our internal-only fields before writing CRON.md so we
+                // don't pollute the canonical file with hash sidecars etc.
+                const cleanDraft = { ...record.draft };
+                if (idx >= 0)
+                    jobs[idx] = cleanDraft;
+                else
+                    jobs.push(cleanDraft);
+                writeCronFileAt(targetFile, parsed, jobs);
+            }
+            catch (writeErr) {
+                res.status(500).json({ ok: false, error: 'failed to write CRON.md: ' + String(writeErr) });
+                return;
+            }
+            deleteDraft(jobName);
+            // Hot-reload the scheduler so the new published def takes effect on
+            // the next tick instead of waiting for the next file scan.
+            try {
+                const gw = await getGateway();
+                const sched = gw.cronScheduler;
+                if (sched && typeof sched.reloadJobs === 'function')
+                    sched.reloadJobs();
+            }
+            catch { /* non-fatal */ }
+            // Broadcast so other tabs refresh task cards immediately.
+            try {
+                broadcastEvent({ type: 'cron_published', data: { job: jobName } });
+            }
+            catch { /* non-fatal */ }
+            res.json({ ok: true, message: `Published "${jobName}". Schedule fires from this version starting now.` });
+        }
+        catch (err) {
+            res.status(500).json({ ok: false, error: String(err) });
+        }
+    });
     app.get('/api/cron/:job/hooks-status', async (req, res) => {
         try {
             const jobName = req.params.job;
@@ -21179,8 +21329,18 @@ if('serviceWorker' in navigator){navigator.serviceWorker.getRegistrations().then
              when editing a saved task (set by openEditCronModal). Disabled
              during an in-flight run. -->
         <button class="btn btn-sm btn-success" id="cron-run-once-btn" onclick="runCronOnceFromModal()" style="display:none;font-size:12px;padding:6px 14px">▶ Run task once</button>
+        <!-- PRD §11 Phase 5b / 1.18.105: draft state badge. Updates via
+             refreshCronDraftBadge(jobName) after every save / load /
+             publish / discard. -->
+        <span id="cron-draft-badge" style="display:none;font-size:11px;padding:3px 8px;border-radius:999px;font-weight:500"></span>
       </div>
       <button onclick="closeCronModal()">Cancel</button>
+      <!-- PRD §11 Phase 5b / 1.18.105: Save as draft / Publish split for
+           saved tasks. Visible only when editing an already-published
+           task (cron-modal-save is hidden for those). -->
+      <button class="btn btn-sm" id="cron-discard-draft-btn" onclick="discardCronDraft()" style="display:none;font-size:12px;padding:6px 12px">Discard draft</button>
+      <button class="btn btn-sm" id="cron-save-draft-btn" onclick="saveCronAsDraft()" style="display:none;font-size:12px;padding:6px 14px">Save as draft</button>
+      <button class="btn-primary" id="cron-publish-btn" onclick="publishCronDraft()" style="display:none">Publish</button>
       <button class="btn-primary" id="cron-modal-save" onclick="saveCronJob()">Create Task</button>
     </div>
   </div>
@@ -27841,6 +28001,8 @@ function openEditCronModal(jobName) {
   _cronPreviewLoadedFor = null;
   document.getElementById('cron-modal-title').textContent = 'Edit: ' + jobName;
   document.getElementById('cron-modal-save').textContent = 'Save Changes';
+  // PRD §11 Phase 5b / 1.18.105: load draft state for footer badge + buttons.
+  if (typeof refreshCronDraftBadge === 'function') refreshCronDraftBadge(jobName);
   document.getElementById('cron-name').value = job.name;
   document.getElementById('cron-name').disabled = true;
   setScheduleFromCron(job.schedule || '0 9 * * *');
@@ -28387,6 +28549,168 @@ async function saveCronJob() {
   }
 }
 
+// ── PRD §11 Phase 5b / 1.18.105: Draft / Publish handlers ───────────
+// Build the same body saveCronJob builds, but POST it as a draft sidecar
+// instead of overwriting CRON.md. The schedule keeps firing the published
+// version until the user clicks Publish.
+function _buildCronJobBodyForDraft() {
+  // Reuse the same field collection logic saveCronJob uses, minus the
+  // PUT/POST round-trip. Returns null when validation fails so the caller
+  // can bail without further work.
+  var name = document.getElementById('cron-name').value.trim();
+  var schedule = document.getElementById('cron-schedule').value.trim();
+  var prompt = document.getElementById('cron-prompt').value.trim();
+  if (!name) { toast('Task name is required', 'error'); return null; }
+  if (!schedule) { toast('Schedule is required', 'error'); return null; }
+  if (!prompt) { toast('Prompt is required', 'error'); return null; }
+  var tier = parseInt(document.getElementById('cron-tier').value);
+  var work_dir = document.getElementById('cron-workdir').value;
+  var mode = document.getElementById('cron-mode').value;
+  var max_hours = mode === 'unleashed' ? parseInt(document.getElementById('cron-maxhours').value) : undefined;
+  var max_retries_val = document.getElementById('cron-max-retries').value;
+  var max_retries = max_retries_val !== '' ? parseInt(max_retries_val) : undefined;
+  var after = document.getElementById('cron-after').value || undefined;
+  var context = document.getElementById('cron-context').value.trim() || undefined;
+  var category = (document.getElementById('cron-category')?.value || '').trim() || undefined;
+  var allowedTools = parseAllowedToolsRaw();
+  var successCriteriaText = (document.getElementById('cron-success-criteria-text')?.value || '').trim();
+  var successSchemaRaw = (document.getElementById('cron-success-schema')?.value || '').trim();
+  var successSchema;
+  if (successSchemaRaw) {
+    try { successSchema = JSON.parse(successSchemaRaw); }
+    catch (e) { toast('Success schema is not valid JSON', 'error'); return null; }
+  }
+  var addDirs = (document.getElementById('cron-add-dirs')?.value || '')
+    .split(/\\r?\\n/).map(function(s){return s.trim();}).filter(Boolean);
+  return {
+    name: name, schedule: schedule, prompt: prompt, tier: tier,
+    enabled: true,
+    work_dir: work_dir || undefined,
+    mode: mode,
+    max_hours: max_hours,
+    max_retries: max_retries,
+    after: after,
+    context: context,
+    category: category,
+    skills: _cronSelectedSkills,
+    allowedTools: allowedTools,
+    allowedMcpServers: _cronSelectedMcp,
+    tags: _cronTags,
+    predictable: typeof _cronPredictable === 'boolean' ? _cronPredictable : true,
+    successCriteriaText: successCriteriaText || undefined,
+    successSchema: successSchema || undefined,
+    addDirs: addDirs.length ? addDirs : undefined,
+  };
+}
+
+async function saveCronAsDraft() {
+  if (!editingCronJob) {
+    toast('Save the task first; drafts apply to existing tasks.', 'info');
+    return;
+  }
+  var body = _buildCronJobBodyForDraft();
+  if (!body) return;
+  try {
+    var r = await apiFetch('/api/cron/' + encodeURIComponent(editingCronJob) + '/draft', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ draft: body, changedBy: 'dashboard' }),
+    });
+    var d = await r.json().catch(function() { return {}; });
+    if (!r.ok || d.ok === false) {
+      toast(d.error || ('Save draft failed (HTTP ' + r.status + ')'), 'error');
+      return;
+    }
+    toast(d.message || 'Draft saved.', 'success');
+    captureCronModalSnapshot();
+    refreshCronDraftBadge(editingCronJob);
+  } catch (err) { toast('Save draft failed: ' + err, 'error'); }
+}
+
+async function publishCronDraft() {
+  if (!editingCronJob) return;
+  if (!confirm('Publish the draft to live? The schedule will start firing the new version on the next tick.')) return;
+  try {
+    var r = await apiFetch('/api/cron/' + encodeURIComponent(editingCronJob) + '/publish', { method: 'POST' });
+    var d = await r.json().catch(function() { return {}; });
+    if (!r.ok || d.ok === false) {
+      toast(d.error || ('Publish failed (HTTP ' + r.status + ')'), 'error');
+      return;
+    }
+    toast(d.message || 'Published.', 'success');
+    refreshCron();
+    refreshCronDraftBadge(editingCronJob);
+  } catch (err) { toast('Publish failed: ' + err, 'error'); }
+}
+
+async function discardCronDraft() {
+  if (!editingCronJob) return;
+  if (!confirm('Discard the unpublished draft? This restores the editor to the published version.')) return;
+  try {
+    var r = await apiFetch('/api/cron/' + encodeURIComponent(editingCronJob) + '/draft', { method: 'DELETE' });
+    var d = await r.json().catch(function() { return {}; });
+    if (!r.ok || d.ok === false) {
+      toast(d.error || ('Discard failed (HTTP ' + r.status + ')'), 'error');
+      return;
+    }
+    toast(d.message || 'Draft discarded.', 'success');
+    refreshCronDraftBadge(editingCronJob);
+    // Reload the modal contents from the published version so the editor
+    // matches what the schedule will fire.
+    if (editingCronJob && typeof openEditCronModal === 'function') {
+      var name = editingCronJob;
+      // openEditCronModal re-fetches and re-populates fields.
+      openEditCronModal(name);
+    }
+  } catch (err) { toast('Discard failed: ' + err, 'error'); }
+}
+
+// Update the draft badge + footer button visibility based on the
+// computed badge state. Called from openEditCronModal after load and
+// after every draft action.
+async function refreshCronDraftBadge(jobName) {
+  var badge = document.getElementById('cron-draft-badge');
+  var saveDraftBtn = document.getElementById('cron-save-draft-btn');
+  var publishBtn = document.getElementById('cron-publish-btn');
+  var discardBtn = document.getElementById('cron-discard-draft-btn');
+  if (!badge || !jobName) return;
+  try {
+    var r = await apiFetch('/api/cron/' + encodeURIComponent(jobName) + '/draft');
+    var d = await r.json();
+    if (!r.ok || !d.ok) {
+      badge.style.display = 'none';
+      if (saveDraftBtn) saveDraftBtn.style.display = '';
+      if (publishBtn) publishBtn.style.display = 'none';
+      if (discardBtn) discardBtn.style.display = 'none';
+      return;
+    }
+    var state = d.badge || 'none';
+    var label, color;
+    if (state === 'up_to_date') { label = '✓ Published, no draft changes'; color = 'var(--green)'; }
+    else if (state === 'ready') { label = '● Ready to publish'; color = 'var(--accent)'; }
+    else if (state === 'rebase_needed') { label = '⚠ Published drifted — review draft'; color = 'var(--yellow)'; }
+    else if (state === 'draft') { label = '✎ Draft (not yet published)'; color = 'var(--accent)'; }
+    else { label = ''; color = ''; }
+    if (label) {
+      badge.style.display = '';
+      badge.textContent = label;
+      badge.style.background = color + '20';
+      badge.style.color = color;
+    } else {
+      badge.style.display = 'none';
+    }
+    // Footer button visibility depends on whether we have a saved task
+    // (editingCronJob) AND whether a draft already exists. Save-as-draft
+    // is always visible when editing; Publish/Discard only when a draft
+    // exists.
+    if (saveDraftBtn) saveDraftBtn.style.display = '';
+    if (publishBtn) publishBtn.style.display = (state === 'ready' || state === 'rebase_needed' || state === 'draft') ? '' : 'none';
+    if (discardBtn) discardBtn.style.display = (state === 'ready' || state === 'rebase_needed' || state === 'draft' || state === 'up_to_date') ? '' : 'none';
+  } catch (err) {
+    if (badge) badge.style.display = 'none';
+  }
+}
+
 // ── Cron Training Chat ───────────────────
 function showCronTraining() {
   document.getElementById('cron-training-section').style.display = '';

package/package.json

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