@graph-tl/graph 0.1.6 → 0.1.9

package/dist/{server-6MALRQNH.js → server-L7KF2UWS.js}

@@ -2,6 +2,9 @@
 import {
   getLicenseTier
 } from "./chunk-WKOEKYTF.js";
+import {
+  handleAgentConfig
+} from "./chunk-ILTJI4ZN.js";
 import {
   EngineError,
   ValidationError,
@@ -25,14 +28,17 @@ import {
   requireString,
   setDbPath,
   updateNode
-} from "./chunk-NWCUIW6D.js";
+} from "./chunk-TWT5GUXW.js";
 
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
   CallToolRequestSchema,
-  ListToolsRequestSchema
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ReadResourceRequestSchema
 } from "@modelcontextprotocol/sdk/types.js";
 
 // src/tools/open.ts
@@ -43,15 +49,28 @@ function handleOpen(input, agent) {
     return { projects: listProjects() };
   }
   let root = getProjectRoot(project);
+  let isNew = false;
   if (!root) {
     root = createNode({
       project,
       summary: goal ?? project,
+      discovery: "pending",
       agent
     });
+    isNew = true;
   }
   const summary = getProjectSummary(project);
-  return { project, root, summary };
+  const result = { project, root, summary };
+  if (isNew) {
+    result.hint = `New project created. Discovery is pending \u2014 interview the user to understand scope and goals, then set discovery to "done" via graph_update before decomposing with graph_plan.`;
+  } else if (root.discovery === "pending") {
+    result.hint = `Discovery is still pending on this project. Complete the discovery interview, then set discovery to "done" via graph_update.`;
+  } else if (summary.actionable > 0) {
+    result.hint = `${summary.actionable} actionable task(s). Use graph_next to claim one.`;
+  } else if (summary.unresolved > 0 && summary.actionable === 0) {
+    result.hint = `All remaining tasks are blocked. Check dependencies with graph_query.`;
+  }
+  return result;
 }
 
 // src/edges.ts
@@ -220,6 +239,12 @@ function handlePlan(input, agent) {
       let project;
       if (parentId) {
         const parentNode = getNode(parentId);
+        if (parentNode.discovery === "pending") {
+          throw new EngineError(
+            "discovery_pending",
+            `Cannot add children to "${parentNode.summary}" \u2014 discovery is pending. Complete the discovery interview first (set discovery to 'done' via graph_update), then decompose.`
+          );
+        }
         project = parentNode.project;
       } else {
         throw new Error(
@@ -286,16 +311,21 @@ function handleUpdate(input, agent) {
   const resolvedIds = [];
   let project = null;
   for (const entry of updates) {
+    let evidence = entry.add_evidence;
+    if (entry.resolved_reason) {
+      evidence = [...evidence ?? [], { type: "note", ref: entry.resolved_reason }];
+    }
     const node = updateNode({
       node_id: entry.node_id,
       agent,
       resolved: entry.resolved,
+      discovery: entry.discovery,
       state: entry.state,
       summary: entry.summary,
       properties: entry.properties,
       add_context_links: entry.add_context_links,
       remove_context_links: entry.remove_context_links,
-      add_evidence: entry.add_evidence
+      add_evidence: evidence
     });
     updated.push({ node_id: node.id, rev: node.rev });
     if (entry.resolved === true) {
@@ -303,10 +333,42 @@ function handleUpdate(input, agent) {
       project = node.project;
     }
   }
+  const autoResolved = [];
+  if (resolvedIds.length > 0) {
+    const seen = new Set(resolvedIds);
+    const queue = [...resolvedIds];
+    while (queue.length > 0) {
+      const nodeId = queue.shift();
+      const node = getNode(nodeId);
+      if (!node?.parent) continue;
+      const parentId = node.parent;
+      if (seen.has(parentId)) continue;
+      seen.add(parentId);
+      const parent = getNode(parentId);
+      if (!parent || parent.resolved) continue;
+      const children = getChildren(parentId);
+      if (children.length === 0) continue;
+      if (children.every((c) => c.resolved)) {
+        const resolved = updateNode({
+          node_id: parentId,
+          agent,
+          resolved: true,
+          add_evidence: [{ type: "note", ref: "Auto-resolved: all children completed" }]
+        });
+        updated.push({ node_id: resolved.id, rev: resolved.rev });
+        resolvedIds.push(parentId);
+        autoResolved.push({ node_id: parentId, summary: parent.summary });
+        queue.push(parentId);
+      }
+    }
+  }
   const result = { updated };
   if (resolvedIds.length > 0 && project) {
     result.newly_actionable = findNewlyActionable(project, resolvedIds);
   }
+  if (autoResolved.length > 0) {
+    result.auto_resolved = autoResolved;
+  }
   return result;
 }
 
@@ -373,6 +435,7 @@ function buildNodeTree(nodeId, currentDepth, maxDepth) {
     id: node.id,
     summary: node.summary,
     resolved: node.resolved,
+    discovery: node.discovery,
     state: node.state
   };
   if (children.length === 0) {
@@ -866,9 +929,26 @@ function handleHistory(input) {
 
 // src/tools/onboard.ts
 function handleOnboard(input) {
-  const project = requireString(input?.project, "project");
   const evidenceLimit = optionalNumber(input?.evidence_limit, "evidence_limit", 1, 50) ?? 20;
   const db = getDb();
+  let project = optionalString(input?.project, "project");
+  if (!project) {
+    const projects = listProjects();
+    if (projects.length === 0) {
+      return {
+        projects: [],
+        hint: 'No projects yet. Create one with graph_open({ project: "my-project", goal: "..." }).'
+      };
+    }
+    if (projects.length === 1) {
+      project = projects[0].project;
+    } else {
+      return {
+        projects,
+        hint: `${projects.length} projects found. Call graph_onboard with a specific project name.`
+      };
+    }
+  }
   const root = getProjectRoot(project);
   if (!root) {
     throw new EngineError("project_not_found", `Project not found: ${project}`);
@@ -885,6 +965,7 @@ function handleOnboard(input) {
       id: child.id,
       summary: child.summary,
       resolved: child.resolved === 1,
+      discovery: child.discovery,
       children: grandchildren.map((gc) => ({
         id: gc.id,
         summary: gc.summary,
@@ -919,6 +1000,7 @@ function handleOnboard(input) {
     }
   }
   const context_links = [...linkSet].sort();
+  const knowledgeRows = db.prepare("SELECT key, content, updated_at FROM knowledge WHERE project = ? ORDER BY updated_at DESC").all(project);
   const actionableRows = db.prepare(
     `SELECT n.id, n.summary, n.properties FROM nodes n
        WHERE n.project = ? AND n.resolved = 0
@@ -941,115 +1023,88 @@ function handleOnboard(input) {
     summary: row.summary,
     properties: JSON.parse(row.properties)
   }));
+  const oneDayAgo = new Date(Date.now() - 24 * 60 * 60 * 1e3).toISOString();
+  const recentlyResolvedRows = db.prepare(
+    `SELECT id, summary, updated_at,
+       (SELECT json_extract(value, '$.agent') FROM json_each(evidence) ORDER BY json_extract(value, '$.timestamp') DESC LIMIT 1) as last_agent
+       FROM nodes
+       WHERE project = ? AND resolved = 1 AND updated_at > ?
+       ORDER BY updated_at DESC
+       LIMIT 10`
+  ).all(project, oneDayAgo);
+  const recently_resolved = recentlyResolvedRows.map((row) => ({
+    id: row.id,
+    summary: row.summary,
+    resolved_at: row.updated_at,
+    agent: row.last_agent ?? "unknown"
+  }));
+  const lastActivityRow = db.prepare("SELECT MAX(updated_at) as last FROM nodes WHERE project = ?").get(project);
+  const last_activity = lastActivityRow.last;
+  let hint;
+  if (root.discovery === "pending") {
+    hint = `Discovery is pending. Interview the user to understand scope and goals, write knowledge entries with findings, then set discovery to "done" via graph_update before decomposing with graph_plan.`;
+  } else if (actionable.length > 0) {
+    const recentNote = recently_resolved.length > 0 ? ` ${recently_resolved.length} task(s) resolved recently.` : "";
+    hint = `${actionable.length} actionable task(s) ready.${recentNote} Use graph_next({ project: "${project}", claim: true }) to claim one.`;
+  } else if (summary.unresolved > 0 && summary.actionable === 0) {
+    hint = `All remaining tasks are blocked. Check dependencies with graph_query.`;
+  } else if (summary.total <= 1 && root.discovery !== "pending") {
+    hint = `Project is empty \u2014 use graph_plan to decompose the goal into tasks.`;
+  }
   return {
     project,
+    goal: root.summary,
+    discovery: root.discovery,
+    hint,
     summary,
     tree,
     recent_evidence,
     context_links,
+    knowledge: knowledgeRows,
+    recently_resolved,
+    last_activity,
     actionable
   };
 }
 
-// src/tools/agent-config.ts
-var AGENT_PROMPT = `---
-name: graph
-description: Use this agent for tasks tracked in Graph. Enforces the claim-work-resolve workflow \u2014 always checks graph_next before working, adds new work to the graph before executing, and resolves with evidence.
-tools: Read, Edit, Write, Bash, Glob, Grep, Task(Explore)
-model: sonnet
----
-
-You are a graph-optimized agent. You execute tasks tracked in a Graph project. Follow this workflow strictly. The human directs, you execute through the graph.
-
-# Workflow
-
-## 1. ORIENT
-On your first call, orient yourself:
-\`\`\`
-graph_onboard({ project: "<project-name>" })
-\`\`\`
-Read the summary, recent evidence, context links, and actionable tasks. Understand what was done and what's left.
-
-## 2. CLAIM
-Get your next task:
-\`\`\`
-graph_next({ project: "<project-name>", claim: true })
-\`\`\`
-Read the task summary, ancestor chain (for scope), resolved dependencies (for context on what was done before you), and context links (for files to look at).
-
-## 3. PLAN
-If you discover work that isn't in the graph, add it BEFORE executing:
-\`\`\`
-graph_plan({ nodes: [{ ref: "new-work", parent_ref: "<parent-id>", summary: "..." }] })
-\`\`\`
-Never execute ad-hoc work. The graph is the source of truth.
-
-When decomposing work:
-- Set dependencies on LEAF nodes, not parent nodes. If "Page A" depends on "Layout", the dependency is from "Page A" to "Layout", not from the "Pages" parent to "Layout".
-- Keep tasks small and specific. A task should be completable in one session.
-- Parent nodes are organizational \u2014 they resolve when all children resolve. Don't put work in parent nodes.
-
-## 4. WORK
-Execute the claimed task. While working:
-- Annotate key code changes with \`// [sl:nodeId]\` where nodeId is the task you're working on
-- This creates a traceable link from code back to the task, its evidence, and its history
-- Build and run tests before considering a task done
-
-## 5. RESOLVE
-When done, resolve the task with evidence:
-\`\`\`
-graph_update({ updates: [{
-  node_id: "<task-id>",
-  resolved: true,
-  add_evidence: [
-    { type: "note", ref: "What you did and why" },
-    { type: "git", ref: "<commit-hash> \u2014 <summary>" },
-    { type: "test", ref: "Test results" }
-  ],
-  add_context_links: ["path/to/files/you/touched"]
-}] })
-\`\`\`
-Evidence is mandatory. At minimum, include one note explaining what you did.
-
-## 6. PAUSE
-After resolving a task, STOP. Tell the user:
-- What you just completed
-- What the next actionable task is
-- Wait for the user to say "continue" before claiming the next task
-
-The user controls the pace. Do not auto-claim the next task.
-
-# Rules
-
-- NEVER start work without a claimed task
-- NEVER resolve without evidence
-- NEVER execute ad-hoc work \u2014 add it to the graph first via graph_plan
-- NEVER auto-continue to the next task \u2014 pause and let the user decide
-- ALWAYS build and test before resolving
-- ALWAYS include context_links for files you modified when resolving
-- If a parent task becomes actionable (all children resolved), resolve it with a summary of what its children accomplished
-- If you're approaching context limits, ensure your current task's state is captured (update with evidence even if not fully resolved) so the next agent can pick up where you left off
-
-# Common mistakes to avoid
-
-- Setting dependencies on parent nodes instead of leaf nodes
-- Running project scaffolding tools (create-next-app, etc.) before planning in the graph
-- Resolving tasks without running tests
-- Doing work that isn't tracked in the graph
-- Continuing to the next task without pausing for user review
-`;
-function handleAgentConfig(dbPath) {
-  const tier = getLicenseTier(dbPath);
-  if (tier !== "pro") {
-    throw new EngineError(
-      "free_tier_limit",
-      "The graph-optimized agent configuration is a pro feature. Activate a license key to unlock it."
+// src/tools/tree.ts
+function buildTree(node, currentDepth, maxDepth, stats) {
+  stats.total++;
+  if (node.resolved) stats.resolved++;
+  const children = getChildren(node.id);
+  const treeNode = {
+    id: node.id,
+    summary: node.summary,
+    resolved: node.resolved,
+    properties: node.properties
+  };
+  if (children.length === 0) return treeNode;
+  if (currentDepth < maxDepth) {
+    treeNode.children = children.map(
+      (child) => buildTree(child, currentDepth + 1, maxDepth, stats)
     );
+  } else {
+    treeNode.child_count = children.length;
+  }
+  return treeNode;
+}
+function handleTree(input) {
+  const project = requireString(input?.project, "project");
+  const depth = optionalNumber(input?.depth, "depth", 1, 20) ?? 10;
+  const root = getProjectRoot(project);
+  if (!root) {
+    throw new EngineError("project_not_found", `Project not found: ${project}`);
   }
+  const stats = { total: 0, resolved: 0 };
+  const tree = buildTree(root, 0, depth, stats);
   return {
-    agent_file: AGENT_PROMPT,
-    install_path: ".claude/agents/graph.md",
-    instructions: "Save the agent_file content to .claude/agents/graph.md in your project root. Claude Code will automatically discover it and use it when tasks match the agent description."
+    project,
+    tree,
+    stats: {
+      total: stats.total,
+      resolved: stats.resolved,
+      unresolved: stats.total - stats.resolved
+    }
   };
 }
 
@@ -1132,10 +1187,10 @@ function handleKnowledgeSearch(input) {
 
 // src/gates.ts
 var FREE_LIMITS = {
-  maxProjects: 1,
-  maxNodesPerProject: 50,
-  onboardEvidenceLimit: 5,
-  scopeEnabled: false
+  maxProjects: Infinity,
+  maxNodesPerProject: Infinity,
+  onboardEvidenceLimit: 50,
+  scopeEnabled: true
 };
 function checkNodeLimit(tier, project, adding) {
   if (tier === "pro") return;
@@ -1163,9 +1218,11 @@ function capEvidenceLimit(tier, requested) {
   const max = tier === "pro" ? requested ?? 20 : FREE_LIMITS.onboardEvidenceLimit;
   return Math.min(requested ?? max, tier === "pro" ? 50 : FREE_LIMITS.onboardEvidenceLimit);
 }
-function checkScope(tier, scope) {
-  if (tier === "pro") return scope;
-  return void 0;
+function checkKnowledgeTier(_tier) {
+  return;
+}
+function checkScope(_tier, scope) {
+  return scope;
 }
 
 // src/server.ts
@@ -1310,7 +1367,7 @@ var TOOLS = [
   },
   {
     name: "graph_update",
-    description: "Update one or more nodes. Can change resolved, state, summary, properties (merged), context_links, and add evidence. When resolving nodes, returns newly_actionable \u2014 nodes that became unblocked. ENFORCED: Resolving a node requires evidence \u2014 the engine rejects resolved=true if the node has no existing evidence and no add_evidence in the call. Include at least one add_evidence entry (type: 'git' for commits, 'note' for what was done and why, 'test' for results). Also add context_links to files you modified.",
+    description: "Update one or more nodes. Can change resolved, state, summary, properties (merged), context_links, and add evidence. When resolving nodes, returns newly_actionable \u2014 nodes that became unblocked. ENFORCED: Resolving a node requires evidence \u2014 use resolved_reason (shorthand, auto-creates note) or add_evidence array (type: 'git' for commits, 'note' for what was done and why, 'test' for results). Also add context_links to files you modified.",
     inputSchema: {
       type: "object",
       properties: {
@@ -1321,6 +1378,8 @@ var TOOLS = [
             properties: {
               node_id: { type: "string" },
               resolved: { type: "boolean" },
+              resolved_reason: { type: "string", description: "Shorthand: auto-creates a note evidence entry. Use instead of add_evidence for simple cases." },
+              discovery: { type: "string", description: "Discovery phase status: 'pending' or 'done'. Set to 'done' after completing discovery interview." },
               state: { description: "Agent-defined state, any type" },
               summary: { type: "string" },
               properties: {
@@ -1472,18 +1531,32 @@ var TOOLS = [
     inputSchema: {
       type: "object",
       properties: {
-        project: { type: "string", description: "Project name (e.g. 'my-project')" },
+        project: { type: "string", description: "Project name (e.g. 'my-project'). Omit to auto-select (works when there's exactly one project)." },
         evidence_limit: {
           type: "number",
           description: "Max evidence entries to return (default 20, max 50)"
         }
+      }
+    }
+  },
+  {
+    name: "graph_tree",
+    description: "Full tree visualization for a project. Returns the complete task hierarchy with resolve status. Use when you need to see the whole project structure beyond graph_context's single-node neighborhood.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        project: { type: "string", description: "Project name (e.g. 'my-project')" },
+        depth: {
+          type: "number",
+          description: "Max tree depth to return (default 10, max 20)"
+        }
       },
       required: ["project"]
     }
   },
   {
     name: "graph_agent_config",
-    description: "Returns the graph-optimized agent configuration file for Claude Code. Pro tier only. Save the returned content to .claude/agents/graph.md to enable the graph workflow agent.",
+    description: "Returns the graph-optimized agent configuration file for Claude Code. Save the returned content to .claude/agents/graph.md to enable the graph workflow agent.",
     inputSchema: {
       type: "object",
       properties: {}
@@ -1544,7 +1617,7 @@ async function startServer() {
   const tier = getLicenseTier(DB_PATH);
   const server = new Server(
     { name: "graph", version: PKG_VERSION },
-    { capabilities: { tools: {} } }
+    { capabilities: { tools: {}, resources: {} } }
   );
   checkForUpdate();
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
@@ -1558,7 +1631,7 @@ async function startServer() {
         case "graph_open": {
           const openArgs = args;
           if (openArgs?.project) {
-            const { getProjectRoot: getProjectRoot2 } = await import("./nodes-7UZATPPU.js");
+            const { getProjectRoot: getProjectRoot2 } = await import("./nodes-4OJBNDHG.js");
             if (!getProjectRoot2(openArgs.project)) {
               checkProjectLimit(tier);
             }
@@ -1569,7 +1642,7 @@ async function startServer() {
         case "graph_plan": {
           const planArgs = args;
           if (planArgs?.nodes?.length > 0) {
-            const { getNode: getNode2 } = await import("./nodes-7UZATPPU.js");
+            const { getNode: getNode2 } = await import("./nodes-4OJBNDHG.js");
             const firstParent = planArgs.nodes[0]?.parent_ref;
             if (firstParent && typeof firstParent === "string" && !planArgs.nodes.some((n) => n.ref === firstParent)) {
               const parentNode = getNode2(firstParent);
@@ -1613,19 +1686,26 @@ async function startServer() {
           result = handleOnboard(onboardArgs);
           break;
         }
+        case "graph_tree":
+          result = handleTree(args);
+          break;
         case "graph_agent_config":
-          result = handleAgentConfig(DB_PATH);
+          result = handleAgentConfig();
           break;
         case "graph_knowledge_write":
+          checkKnowledgeTier(tier);
           result = handleKnowledgeWrite(args, AGENT_IDENTITY);
           break;
         case "graph_knowledge_read":
+          checkKnowledgeTier(tier);
           result = handleKnowledgeRead(args);
           break;
         case "graph_knowledge_delete":
+          checkKnowledgeTier(tier);
           result = handleKnowledgeDelete(args);
           break;
         case "graph_knowledge_search":
+          checkKnowledgeTier(tier);
           result = handleKnowledgeSearch(args);
           break;
         default:
@@ -1659,6 +1739,79 @@ async function startServer() {
       };
     }
   });
+  server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => ({
+    resourceTemplates: [
+      {
+        uriTemplate: "graph://{project}/tree",
+        name: "Project Tree",
+        description: "Full task tree for a project with resolve status",
+        mimeType: "application/json"
+      },
+      {
+        uriTemplate: "graph://{project}/knowledge",
+        name: "Project Knowledge",
+        description: "All knowledge entries for a project",
+        mimeType: "application/json"
+      },
+      {
+        uriTemplate: "graph://{project}/knowledge/{key}",
+        name: "Knowledge Entry",
+        description: "A specific knowledge entry",
+        mimeType: "application/json"
+      }
+    ]
+  }));
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    try {
+      const { listProjects: listProjects2 } = await import("./nodes-4OJBNDHG.js");
+      const projects = listProjects2();
+      const resources = projects.flatMap((p) => [
+        {
+          uri: `graph://${p.project}/tree`,
+          name: `${p.project} \u2014 Tree`,
+          description: `Task tree: ${p.total} nodes (${p.resolved} resolved)`,
+          mimeType: "application/json"
+        },
+        {
+          uri: `graph://${p.project}/knowledge`,
+          name: `${p.project} \u2014 Knowledge`,
+          description: `Knowledge entries for ${p.project}`,
+          mimeType: "application/json"
+        }
+      ]);
+      return { resources };
+    } catch {
+      return { resources: [] };
+    }
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    const match = uri.match(/^graph:\/\/([^/]+)\/(.+)$/);
+    if (!match) {
+      throw new Error(`Invalid resource URI: ${uri}`);
+    }
+    const [, project, path] = match;
+    if (path === "tree") {
+      const result = handleTree({ project });
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+    if (path === "knowledge") {
+      const result = handleKnowledgeRead({ project });
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+    const knowledgeMatch = path.match(/^knowledge\/(.+)$/);
+    if (knowledgeMatch) {
+      const result = handleKnowledgeRead({ project, key: knowledgeMatch[1] });
+      return {
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+    throw new Error(`Unknown resource path: ${path}`);
+  });
   const transport = new StdioServerTransport();
   await server.connect(transport);
   const checkpointInterval = setInterval(() => {
@@ -1681,4 +1834,4 @@ async function startServer() {
 export {
   startServer
 };
-//# sourceMappingURL=server-6MALRQNH.js.map
+//# sourceMappingURL=server-L7KF2UWS.js.map