@graph-tl/graph 0.1.6 → 0.1.8

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

@@ -2,6 +2,9 @@
 import {
   getLicenseTier
 } from "./chunk-WKOEKYTF.js";
+import {
+  handleAgentConfig
+} from "./chunk-ILTJI4ZN.js";
 import {
   EngineError,
   ValidationError,
@@ -25,7 +28,7 @@ import {
   requireString,
   setDbPath,
   updateNode
-} from "./chunk-NWCUIW6D.js";
+} from "./chunk-TWT5GUXW.js";
 
 // src/server.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -43,15 +46,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 +236,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(
@@ -290,6 +312,7 @@ function handleUpdate(input, agent) {
       node_id: entry.node_id,
       agent,
       resolved: entry.resolved,
+      discovery: entry.discovery,
       state: entry.state,
       summary: entry.summary,
       properties: entry.properties,
@@ -303,10 +326,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 +428,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 +922,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 +958,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 +993,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 +1016,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 +1180,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 +1211,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
@@ -1321,6 +1371,7 @@ var TOOLS = [
             properties: {
               node_id: { type: "string" },
               resolved: { type: "boolean" },
+              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 +1523,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: {}
@@ -1558,7 +1623,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 +1634,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 +1678,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:
@@ -1681,4 +1753,4 @@ async function startServer() {
 export {
   startServer
 };
-//# sourceMappingURL=server-6MALRQNH.js.map
+//# sourceMappingURL=server-6TNHZCUW.js.map