taskswipe-mcp 0.1.0 → 0.2.1

package/src/tools.js

@@ -13,7 +13,10 @@
 //     can undo a batch.
 // ─────────────────────────────────────────────────────────────────────────────
 
-import { readState, mutate } from './store.js'
+import { readState, mutate, currentUser } from './store.js'
+import { buildBrief, buildDetail } from './brief.js'
+import { isOsOwner, osConfigured, osStatus, readNote, searchNotes, writeNote, appendNote, ensureFrontmatter, notePathFrom } from './os.js'
+import { ob1Configured, ob1Status, searchOb1, captureOb1 } from './ob1.js'
 
 const MAX_ADD = 10
 const uid = () => Math.random().toString(36).slice(2, 11)
@@ -23,6 +26,27 @@ const today = () => {
 }
 
 const arr = (v) => (Array.isArray(v) ? v : [])
+const num = (v) => (Number.isFinite(+v) ? +v : 0)
+
+// Mirrors GOAL_FRAMES and creditGoal in src/lib/goals.js. Duplicated rather
+// than imported because this package ships standalone to npm and cannot reach
+// into the app's src/. If the goal model changes there, change it here too.
+const GOAL_FRAMES = ['3month', '6month', 'yearly', '3year', '7year']
+function creditGoal(goals = {}, { goalId, goalFrame, squares }) {
+  if (!goalId || !squares) return goals || {}
+  const frames = goalFrame && GOAL_FRAMES.includes(goalFrame) ? [goalFrame] : GOAL_FRAMES
+  const next = { ...(goals || {}) }
+  for (const frame of frames) {
+    const list = arr(next[frame])
+    const idx = list.findIndex(g => g.id === goalId)
+    if (idx < 0) continue
+    next[frame] = list.map((g, i) => (i === idx
+      ? { ...g, earnedBricks: Math.max(0, num(g.earnedBricks) + squares) }
+      : g))
+    return next
+  }
+  return goals || {}
+}
 
 /** Match a task the way a person refers to it: by substring, not by id. */
 function findTask(list, ref) {
@@ -43,11 +67,55 @@ function findTask(list, ref) {
 }
 
 export const TOOLS = [
+  // FIRST CALL, ALWAYS. Six tools covering three of twenty-five tabs left an
+  // agent guessing what existed and stitching several reads into a picture. One
+  // bounded call now describes the whole system — see brief.js for why it
+  // summarises rather than serialising.
+  {
+    name: 'brief',
+    title: 'The whole picture, briefly',
+    description:
+      'START HERE for anything about how the user is doing, what they should do '
+      + 'next, or what is going on in any part of their life. Returns a compact '
+      + 'snapshot of the ENTIRE app — today, what needs attention ranked by '
+      + 'severity, and a one-line state for every area (habits, stacks, goals, '
+      + 'food, lift, walk, mind, study, squares and the rest). About a kilobyte '
+      + 'whether they joined yesterday or two years ago. Follow with detail() '
+      + 'for depth on one area.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async run() {
+      const { state } = await readState()
+      return buildBrief(state)
+    },
+  },
+
+  {
+    name: 'detail',
+    title: 'One area, in depth',
+    description:
+      'Depth on ONE area named by brief(). Pass any key from the brief\'s '
+      + '`areas` — today, dropped, backlog, docket, habits, stacks, goals, '
+      + 'food, lift, mind, study, squares, lists, frame, business, people, '
+      + 'things, missions. DROPPED is LOG\'s pile of unfinished tasks from '
+      + 'earlier days. Still summarised: you get what someone would reason '
+      + 'with, not the raw rows.',
+    inputSchema: {
+      type: 'object',
+      properties: { area: { type: 'string', description: 'e.g. "habits", "food", "study"' } },
+      required: ['area'],
+      additionalProperties: false,
+    },
+    async run({ area }) {
+      const { state } = await readState()
+      return buildDetail(state, area)
+    },
+  },
+
   {
     name: 'today',
     title: "Today's plan",
     description:
-      "What TASK//SWIPE has for today: open and completed tasks, the core task, "
+      "What TASKKA has for today: open and completed tasks, the core task, "
       + "the day score if posted, and today's timed blocks. Call this before "
       + "answering anything about what the user is doing today.",
     inputSchema: { type: 'object', properties: {}, additionalProperties: false },
@@ -130,10 +198,19 @@ export const TOOLS = [
       + 'a few words is enough, no id needed. Returns the exact task matched.',
     inputSchema: {
       type: 'object',
-      properties: { task: { type: 'string', minLength: 1, description: 'Any part of the task text.' } },
+      properties: {
+        task: { type: 'string', minLength: 1, description: 'Any part of the task text.' },
+        squares: {
+          type: 'integer', minimum: 0, maximum: 48,
+          description:
+            'How many squares the task was worth. Omit unless the user says — '
+            + 'a recurring rule with a preset worth supplies its own, and '
+            + 'anything else is worth 0 until the user values it in the app.',
+        },
+      },
       required: ['task'], additionalProperties: false,
     },
-    async run({ task }) {
+    async run({ task, squares }) {
       let result = null
       await mutate(state => {
         const list = arr(state.todayTasks)
@@ -141,10 +218,52 @@ export const TOOLS = [
         if (!hit) { result = { ok: false, reason: 'no_match' }; return null }
         if (hit.ambiguous) { result = { ok: false, reason: 'ambiguous', candidates: hit.ambiguous }; return null }
         if (hit.done) { result = { ok: true, already: true, task: hit.text }; return null }
-        result = { ok: true, task: hit.text }
+
+        // Mirrors the COMPLETE_TASK reducer in src/store.jsx. Ticking a task is
+        // not just a flag: it earns squares, writes a history entry, feeds the
+        // level counter, and credits any linked stack or goal. Setting `done`
+        // alone — which is all this did — silently dropped every one of those,
+        // so a recurring task configured as worth 8 earned nothing when ticked
+        // from here. Keep the two in step.
+        //
+        // Coerce like the reducer does: one non-finite value would make
+        // totalSquares NaN, and NaN survives every later addition, quietly
+        // destroying the currency for good.
+        const asked = squares !== undefined ? squares : hit.presetSquares
+        const earned = Number.isFinite(+asked) ? Math.max(0, +asked) : 0
+
+        const newToday = list.map(t => (t.id === hit.id
+          ? {
+              ...t, done: true, completedAt: Date.now(),
+              // Settling the parent settles its steps, as the app does.
+              ...(t.subtasks ? { subtasks: t.subtasks.map(sub => ({ ...sub, done: true })) } : {}),
+            }
+          : t))
+
+        const entry = {
+          ...hit, done: true, squares: earned,
+          stackId: hit.stackId, notes: '', at: Date.now(), source: 'mcp',
+        }
+        if (!entry.goalId) { delete entry.goalId; delete entry.goalFrame }
+
+        const newTotal = num(state.totalSquares) + earned
+        const leveledUp = earned > 0
+          && Math.floor(num(state.totalSquares) / 48) !== Math.floor(newTotal / 48)
+
+        const newStacks = hit.stackId
+          ? arr(state.stacks).map(st => (st.id === hit.stackId
+              ? { ...st, completions: [...arr(st.completions), { date: today(), task: hit.text }] }
+              : st))
+          : state.stacks
+
+        result = { ok: true, task: hit.text, squares: earned, total: newTotal, leveledUp }
         return {
           ...state,
-          todayTasks: list.map(t => (t.id === hit.id ? { ...t, done: true, completedAt: Date.now() } : t)),
+          todayTasks: newToday,
+          achievedTasks: [entry, ...arr(state.achievedTasks)],
+          totalSquares: newTotal,
+          stacks: newStacks,
+          goals: earned > 0 ? creditGoal(state.goals, { goalId: entry.goalId, goalFrame: entry.goalFrame, squares: earned }) : state.goals,
         }
       })
       if (!result?.ok && result?.reason === 'no_match') {
@@ -153,7 +272,15 @@ export const TOOLS = [
       if (result?.reason === 'ambiguous') {
         return { ok: false, message: `That matches several: ${result.candidates.join(', ')}. Be more specific.` }
       }
-      return { ok: true, message: result.already ? `"${result.task}" was already done.` : `Ticked off "${result.task}".` }
+      if (result.already) return { ok: true, message: `"${result.task}" was already done.` }
+      const earned = result.squares
+        ? ` +${result.squares} square${result.squares === 1 ? '' : 's'} (${result.total} total)`
+        : ''
+      return {
+        ok: true,
+        message: `Ticked off "${result.task}"${earned}.`
+          + (result.leveledUp ? ' That completed a brick — level up.' : ''),
+      }
     },
   },
 
@@ -201,6 +328,51 @@ export const TOOLS = [
     },
   },
 
+  {
+    name: 'recover_dropped',
+    title: 'Put a DROPPED task back on today',
+    description:
+      'LOG → DROPPED holds tasks that aged out unfinished from earlier days. '
+      + 'This puts one back on today. Refer to it by any part of its text. '
+      + 'Does not charge decay. Use detail({ area: "dropped" }) first if you '
+      + 'do not know the wording.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        task: { type: 'string', minLength: 1, description: 'Any part of the dropped task text.' },
+      },
+      required: ['task'],
+      additionalProperties: false,
+    },
+    async run({ task }) {
+      let result = null
+      await mutate(state => {
+        const list = arr(state.missedTasks)
+        const hit = findTask(list, task)
+        if (!hit) { result = { ok: false, reason: 'no_match' }; return null }
+        if (hit.ambiguous) { result = { ok: false, reason: 'ambiguous', candidates: hit.ambiguous }; return null }
+        const { expiredDate, ...rest } = hit
+        const already = arr(state.todayTasks).find(t => !t.done && (t.text || '').toLowerCase() === (rest.text || '').toLowerCase())
+        result = { ok: true, task: rest.text, already: !!already }
+        return {
+          ...state,
+          missedTasks: list.filter(t => t.id !== hit.id),
+          todayTasks: already
+            ? state.todayTasks
+            : [...arr(state.todayTasks), { ...rest, id: uid(), done: false, createdDate: today(), source: 'mcp' }],
+        }
+      })
+      if (result?.reason === 'no_match') {
+        return { ok: false, message: `Nothing in DROPPED matches "${task}". Call detail({ area: "dropped" }).` }
+      }
+      if (result?.reason === 'ambiguous') {
+        return { ok: false, message: `That matches several in DROPPED: ${result.candidates.join(', ')}. Be more specific.` }
+      }
+      if (result.already) return { ok: true, message: `"${result.task}" was already on today. Removed from DROPPED.` }
+      return { ok: true, message: `Put "${result.task}" back on today from DROPPED.` }
+    },
+  },
+
   {
     name: 'search',
     title: 'Search everything',
@@ -224,9 +396,14 @@ export const TOOLS = [
         if (text && String(text).toLowerCase().includes(q)) hits.push({ where, text: String(text), ...extra })
       }
       arr(state.todayTasks).forEach(t => add('today', t.text, { done: !!t.done }))
+      arr(state.missedTasks).forEach(t => add('dropped', t.text, { expired: t.expiredDate || null }))
+      arr(state.cutTasks).forEach(t => add('cut', t.text))
       arr(state.backlogTasks).forEach(t => add('backlog', t.text))
+      arr(state.docketTasks).forEach(t => add('docket', t.text || t.task))
       arr(state.taskDatabase).forEach(t => add('database', t.text))
       arr(state.ideas).forEach(i => add('ideas', i.text))
+      arr(state.businessIdeas).forEach(i => add('business', i.title, { stage: i.stage || 'spark' }))
+      arr(state.people).forEach(p => add('people', p.name, { role: p.role || null }))
       arr(state.decompress).forEach(d => add('decompress', d.text))
       Object.entries(state.journal || {}).forEach(([date, entries]) =>
         arr(entries).forEach(e => add('journal', e?.text, { date })))
@@ -237,6 +414,183 @@ export const TOOLS = [
       return { query, count: hits.length, results: hits.slice(0, limit) }
     },
   },
+
+  {
+    name: 'os_search',
+    title: 'Search Callum OS',
+    description:
+      'Search Callum OS, the life wiki: businesses, portfolio, knowledge, '
+      + 'life areas and decisions. Use this when the question is about a '
+      + 'company, a written decision, or anything that lives in the vault '
+      + 'rather than today\'s TASKKA tasks.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', minLength: 2 },
+        limit: { type: 'integer', minimum: 1, maximum: 40, default: 12 },
+      },
+      required: ['query'],
+      additionalProperties: false,
+    },
+    async run({ query, limit = 12 }) {
+      const user = await currentUser()
+      if (!isOsOwner(user)) throw new Error('Callum OS is locked to the vault owner.')
+      if (!osConfigured()) throw new Error('Callum OS is not configured on this server.')
+      return searchNotes(query, limit)
+    },
+  },
+
+  {
+    name: 'os_read',
+    title: 'Read a Callum OS note',
+    description:
+      'Read one markdown note from Callum OS by path, e.g. "index.md", '
+      + '"10 Businesses/Care in Movement/index.md", or "60 Life/index.md". '
+      + 'Call os_search first if you do not know the path.',
+    inputSchema: {
+      type: 'object',
+      properties: { path: { type: 'string', minLength: 1, maxLength: 400 } },
+      required: ['path'],
+      additionalProperties: false,
+    },
+    async run({ path }) {
+      const user = await currentUser()
+      if (!isOsOwner(user)) throw new Error('Callum OS is locked to the vault owner.')
+      if (!osConfigured()) throw new Error('Callum OS is not configured on this server.')
+      const note = await readNote(path)
+      const text = String(note.text || '')
+      return { ...note, text: text.length > 12000 ? `${text.slice(0, 12000)}\n…[truncated]` : text }
+    },
+  },
+
+  {
+    name: 'os_status',
+    title: 'Callum OS connection',
+    description: 'Whether Callum OS is reachable and how many notes are in the vault.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async run() {
+      const user = await currentUser()
+      if (!isOsOwner(user)) throw new Error('Callum OS is locked to the vault owner.')
+      return osStatus()
+    },
+  },
+
+  {
+    name: 'os_write',
+    title: 'Write a Callum OS note',
+    description:
+      'Create or replace one markdown note in Callum OS. Pass the full vault '
+      + 'path (e.g. "01 Inbox/capture.md" or "10 Businesses/Care in Movement/notes.md"). '
+      + 'This OVERWRITES the file — call os_read first if you are editing. '
+      + 'New notes get YAML frontmatter with type: Note. Never write secrets.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', minLength: 1, maxLength: 400 },
+        text: { type: 'string', minLength: 1, maxLength: 50000 },
+        message: { type: 'string', maxLength: 200 },
+        folder: { type: 'string', description: 'Optional folder when creating from a title instead of a path' },
+        title: { type: 'string', description: 'Optional title used to build a new path under folder' },
+      },
+      additionalProperties: false,
+    },
+    async run({ path, text, message, folder, title }) {
+      const user = await currentUser()
+      if (!isOsOwner(user)) throw new Error('Callum OS is locked to the vault owner.')
+      if (!osConfigured()) throw new Error('Callum OS is not configured on this server.')
+      const target = path || notePathFrom({ folder: folder || '01 Inbox', name: title || 'Note' })
+      if (!target) throw new Error('Need a path or a title for the new note.')
+      const body = ensureFrontmatter(text, { title: title || target.split('/').pop() })
+      const saved = await writeNote({ path: target, text: body, message })
+      return { ok: true, ...saved, message: saved.created ? `Created ${saved.path}` : `Updated ${saved.path}` }
+    },
+  },
+
+  {
+    name: 'os_append',
+    title: 'Append to a Callum OS note',
+    description:
+      'Add text to the end of an existing Callum OS note (creates it if missing). '
+      + 'Use this for log.md, inbox capture, or adding a decision without rewriting the file.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', minLength: 1, maxLength: 400 },
+        text: { type: 'string', minLength: 1, maxLength: 20000 },
+        message: { type: 'string', maxLength: 200 },
+      },
+      required: ['path', 'text'],
+      additionalProperties: false,
+    },
+    async run({ path, text, message }) {
+      const user = await currentUser()
+      if (!isOsOwner(user)) throw new Error('Callum OS is locked to the vault owner.')
+      if (!osConfigured()) throw new Error('Callum OS is not configured on this server.')
+      const saved = await appendNote({ path, text, message })
+      return { ok: true, ...saved, message: `Appended to ${saved.path}` }
+    },
+  },
+
+  {
+    name: 'ob1_status',
+    title: 'OB1 connection',
+    description: 'Whether One Brain / OB1 is reachable and how many thoughts it holds.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    async run() {
+      const user = await currentUser()
+      if (!isOsOwner(user)) throw new Error('OB1 is locked to the vault owner.')
+      return ob1Status()
+    },
+  },
+
+  {
+    name: 'ob1_search',
+    title: 'Search OB1',
+    description:
+      'Search One Brain / OB1, the durable cross-tool memory. Use this for '
+      + 'preferences, lessons, and decisions that should follow Callum between '
+      + 'apps — not for today\'s TASKKA tasks or a whole Callum OS note.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', minLength: 2 },
+        limit: { type: 'integer', minimum: 1, maximum: 20, default: 8 },
+      },
+      required: ['query'],
+      additionalProperties: false,
+    },
+    async run({ query, limit = 8 }) {
+      const user = await currentUser()
+      if (!isOsOwner(user)) throw new Error('OB1 is locked to the vault owner.')
+      if (!ob1Configured()) throw new Error('OB1 is not configured on this server.')
+      return searchOb1(query, { limit })
+    },
+  },
+
+  {
+    name: 'ob1_capture',
+    title: 'Capture to OB1',
+    description:
+      'Save one concise thought to One Brain / OB1. Use this when a map topic, '
+      + 'Parley card, learn, or note should follow Callum into future AI sessions. '
+      + 'Do not dump a whole vault file. Never write secrets.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', minLength: 1, maxLength: 4000 },
+        source: { type: 'string', maxLength: 40, description: 'parley, study-map, note, idea, os' },
+        title: { type: 'string', maxLength: 160 },
+      },
+      required: ['text'],
+      additionalProperties: false,
+    },
+    async run({ text, source, title }) {
+      const user = await currentUser()
+      if (!isOsOwner(user)) throw new Error('OB1 is locked to the vault owner.')
+      if (!ob1Configured()) throw new Error('OB1 is not configured on this server.')
+      return captureOb1({ text, source, title })
+    },
+  },
 ]
 
 export const byName = Object.fromEntries(TOOLS.map(t => [t.name, t]))