dsh-thoughtdag 0.4.4 → 0.4.6

package/lib/index.js

@@ -48,6 +48,14 @@
 //                    enter the attachment store and ride the last user message
 //   POST /claude     the same call, whole answer as JSON
 //   POST /fetch-url  the SPA's link snapshot, through the harness's bounded fetcher
+//
+// The why layer inside the harness: the CLI's library (bundled as ./why.mjs at
+// build time) answers the same four questions here, over the same
+// ~/.thoughtdag index the CLI and the MCP server use — as native harness tools
+// the agent calls like any other (why_check, why_file, why_find, why_recall),
+// as a /why command a person types in the chat, and as a short system-prompt
+// section that says when to ask. Relative paths resolve against the session's
+// working directory.
 // These are canvas-native calls (summaries, condensing, a canvas that is
 // not a mirrored session) — they run on the harness's models but do not
 // enter any session log; a mirrored session's turns go through /followup.
@@ -67,7 +75,7 @@ import { fileURLToPath } from 'node:url'
 import { zstdDecompressSync } from 'node:zlib'
 
 export const name = 'thoughtdag'
-export const inject = ['webServer', 'sessions', 'sessionController', 'agents', 'llm', 'attachments', 'web']
+export const inject = ['webServer', 'sessions', 'sessionController', 'agents', 'llm', 'attachments', 'web', 'tools', 'commands', 'systemPrompt']
 
 const __dirname = fileURLToPath(new URL('.', import.meta.url))
 const APP_DIR = resolve(__dirname, '../dist-app')
@@ -360,6 +368,7 @@ const SOURCE = { kind: 'plugin', plugin: 'dsh-thoughtdag' }
 const FILE_ROOTS = {
   'claude-projects': join(os.homedir(), '.claude', 'projects'),
   'codex-sessions': join(os.homedir(), '.codex', 'sessions'),
+  'pi-sessions': join(os.homedir(), '.pi', 'agent', 'sessions'),
 }
 const FILE_READ_MAX = 256 * 1024 * 1024
 
@@ -631,7 +640,90 @@ async function agentOf(ctx, id) {
   throw new HttpError(404, 'no such session: ' + (r.error?.code ?? r.error?.message ?? 'unknown'))
 }
 
-export function apply(ctx, config) {
+// ── the why layer ──────────────────────────────────────────────────────
+
+/** The working directory a session runs in, as its header records it. */
+const cwdOfSession = (session) => session?.header?.cwd ?? session?.header?.meta?.cwd ?? null
+
+/** A path the person or model typed, made absolute against the session's
+ *  working directory when it is relative; URLs and arxiv ids pass through. */
+function resolveAgainst(cwd, q) {
+  const s = String(q ?? '').trim().replace(/^@/, '')
+  if (!s || /^(https?:\/\/|arxiv:)/i.test(s) || s.startsWith('/') || !cwd) return s
+  return resolve(cwd, s)
+}
+
+/** What the why layer managed to register — served at /why/status so a
+ *  deployment can see it without reading logs. */
+const whyStatus = { loaded: false, tools: [], command: false, prompt: false, error: null }
+
+// the harness's tool names: one family, no collision with its own read/find tools
+const TOOL_NAMES = { why_check: 'why_check', why_file: 'why_file', find: 'why_find', recall_turn: 'why_recall' }
+const PATH_ARGS = new Set(['path'])
+
+const WHY_PROMPT = `ThoughtDAG why layer. The tools why_check, why_file, why_find and why_recall read the local index of past agent conversations (Claude Code, Codex, this harness) — evidence from session logs, not opinion.
+- Before editing a file that may have history, call why_check(path); if it has history, why_file(path) lists the turns that changed it: when, what was asked, what changed, and what the answer said about it.
+- why_find(phrase) finds where exact words were asked or answered; why_recall(session, turn) reads one turn in full.
+Cite what you learn briefly; do not restate whole turns.`
+
+async function installWhyLayer(ctx, config) {
+  const wantTools = config?.whyTools !== false
+  const wantPrompt = config?.whyPrompt !== false
+  if (!wantTools && !wantPrompt) return
+  let why
+  try {
+    why = await import('./why.mjs')
+    why.setQuiet?.(true)
+  } catch (error) {
+    whyStatus.error = error instanceof Error ? error.message : String(error)
+    ctx.logger.warn('[dsh-thoughtdag] why layer not loaded: ' + whyStatus.error)
+    console.error('[dsh-thoughtdag] why layer not loaded: ' + whyStatus.error)
+    return
+  }
+  whyStatus.loaded = true
+  const ask = async (mcpName, args, cwd) => {
+    const a = { ...args }
+    for (const k of PATH_ARGS) if (typeof a[k] === 'string') a[k] = resolveAgainst(cwd, a[k])
+    return why.mcpCall(mcpName, a)
+  }
+  if (wantTools) {
+    // raw definitions: the MCP tool schemas are already JSON Schema, and a
+    // bare import of @deepseek-ai/dsh-tools does not resolve from a linked
+    // plugin directory — the registry accepts either form
+    for (const t of why.MCP_TOOLS) {
+      const name = TOOL_NAMES[t.name] ?? t.name
+      try {
+        ctx.effect(() => ctx.tools.register({
+          name,
+          description: t.description,
+          parameters: t.inputSchema,
+          output: { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: String(value) }] },
+          async execute(args, exec) { return ask(t.name, args ?? {}, cwdOfSession(exec?.agent?.session)) },
+        }), 'thoughtdag: tool ' + name)
+        whyStatus.tools.push(name)
+      } catch (error) {
+        whyStatus.error = `${name}: ${error instanceof Error ? error.message : String(error)}`
+        console.error('[dsh-thoughtdag] tool not registered ' + whyStatus.error)
+      }
+    }
+    ctx.effect(() => ctx.commands.register({
+      name: 'why',
+      description: 'ThoughtDAG: which past conversations touched this file, URL or paper',
+      input: { hint: '<path | url | arxiv:id>' },
+      async handler(inv) {
+        const q = String(inv.rawInput ?? '').trim()
+        if (!q) return { kind: 'error', text: 'usage: /why <path | url | arxiv:id>' }
+        try { return { kind: 'success', text: await ask('why_file', { path: q }, cwdOfSession(inv.agent?.session)) } }
+        catch (error) { return { kind: 'error', text: error instanceof Error ? error.message : String(error) } }
+      },
+    }), 'thoughtdag: /why')
+    whyStatus.command = true
+  }
+  if (wantPrompt && wantTools) { ctx.effect(() => ctx.systemPrompt.section({ name: 'thoughtdag-why', order: 900, text: WHY_PROMPT }), 'thoughtdag: why prompt'); whyStatus.prompt = true }
+  ctx.logger.info('[dsh-thoughtdag] why layer: ' + (wantTools ? 'why_check why_file why_find why_recall, /why' : 'no tools') + (wantPrompt && wantTools ? ', prompt section' : ''))
+}
+
+export async function apply(ctx, config) {
   const prefix = typeof config?.mountPrefix === 'string' && config.mountPrefix.startsWith('/') && config.mountPrefix.length > 1
     ? config.mountPrefix.replace(/\/+$/, '')
     : '/thoughtdag'
@@ -689,6 +781,7 @@ export function apply(ctx, config) {
         if (one[2] === '/log') return sendFile(res, 'application/x-ndjson; charset=utf-8', sessionToJsonl(session))
         return sendJson(res, 200, { session: sessionSummary(session) })
       }
+      if (path === '/why/status' && req.method === 'GET') return sendJson(res, 200, whyStatus)
       // ── the other agents' session files ──
       if (path === '/roots' && req.method === 'GET') {
         const roots = []
@@ -842,4 +935,5 @@ export function apply(ctx, config) {
   ctx.effect(() => ctx.webServer.register({ kind: 'prefix', path: prefix + '/api', handler: api }), 'thoughtdag: api')
   ctx.effect(() => ctx.webServer.register({ kind: 'prefix', path: prefix, handler: staticHandler }), 'thoughtdag: static')
   ctx.logger.info('[dsh-thoughtdag] ThoughtDAG mounted at ' + prefix + '/')
+  await installWhyLayer(ctx, config)
 }