@wwjd/pi-graphify 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0](https://github.com/WianVDM/pi-graphify/compare/pi-graphify-v0.3.0...pi-graphify-v0.4.0) (2026-07-12)
+
+
+### Features
+
+* **commands:** add slash commands and unified /graphify menu ([7c7a566](https://github.com/WianVDM/pi-graphify/commit/7c7a566b4dcda3c7b2d166863a7704a98839669a))
+
 ## [0.3.0](https://github.com/WianVDM/pi-graphify/compare/pi-graphify-v0.2.0...pi-graphify-v0.3.0) (2026-07-12)
 
 

package/README.md

@@ -8,12 +8,6 @@ A [Pi](https://pi.dev) extension that brings [Graphify](https://github.com/Graph
 pi install @wwjd/pi-graphify
 ```
 
-Or run locally during development:
-
-```bash
-pi install .
-```
-
 ## What it does
 
 `pi-graphify` detects the Graphify CLI and a project's `graphify-out/graph.json` graph, then exposes Graphify operations as Pi tools and slash commands. It routes requests through a backend abstraction so the agent can use Graphify without worrying about whether it's talking to the CLI or (in the future) an MCP server.
@@ -29,7 +23,14 @@ When a graph is present, the extension also injects a lightweight hint into the
 
 | Command | Description |
 |---|---|
+| `/graphify` | Open the unified Graphify command menu. |
+| `/graphify-build` | Build or incrementally update the Graphify knowledge graph. |
+| `/graphify-query` | Ask a natural-language question against the graph. |
+| `/graphify-path` | Find the shortest path between two graph nodes. |
+| `/graphify-explain` | Explain a node and its connections in the graph. |
+| `/graphify-affected` | Show the blast radius of changes to one or more files. |
 | `/graphify-status` | Check whether a graph exists and whether the Graphify CLI is compatible. |
+| `/graphify-version` | Report the installed Graphify version and compatibility status. |
 
 ## Current tools
 
@@ -45,15 +46,6 @@ When a graph is present, the extension also injects a lightweight hint into the
 
 ## What's coming
 
-Slash commands for the tools above are planned in the next phase:
-
-- `/graphify-build`
-- `/graphify-query`
-- `/graphify-path`
-- `/graphify-explain`
-- `/graphify-affected`
-- `/graphify-version`
-
 Later phases will add background file watching, MCP backend support, ecosystem integrations, and release readiness work. See [plan/PLAN.md](plan/PLAN.md) for the full roadmap.
 
 ## How it works
@@ -75,13 +67,6 @@ This extension is in early development. The public API, tools, and commands will
 - [Release standards](RELEASE.md)
 - [Agent context](AGENTS.md)
 
-## Development
-
-```bash
-npm run typecheck
-npm run lint
-```
-
 ## License
 
 MIT

package/docs/TESTING.md

@@ -63,7 +63,7 @@ After installing, `graphify` should be available on your PATH. If it is not, add
 
 ## Build a graph for testing
 
-Phase 3 only adds the tools. The `/graphify-build` command is added in Phase 4, so for now build the graph directly with the Graphify CLI.
+You can build the graph with the Graphify CLI directly, or use the `/graphify-build` slash command once the extension is loaded.
 
 The recommended approach for testing `pi-graphify` is a code-only graph. It skips semantic extraction, so it does not require an API key or extra Python dependencies:
 
@@ -85,14 +85,15 @@ Then run the full build:
 graphify .
 ```
 
-Once Phase 4 is complete, `/graphify-build` will be available as an alternative.
+Inside Pi you can also run `/graphify` to open the command menu and select "Build graph", or type `/graphify-build` directly.
 
 ## Verify the extension with Graphify installed
 
 1. Start Pi in a project with a built graph.
 2. You should see a notification: `Graphify graph ready: ...`.
 3. The supported tools should be available to the LLM. You can verify by asking: "What graphify tools are available?" or by checking the system prompt tool list.
-4. Test a tool by asking: "Use the graphify graph to explain how auth works in this codebase."
+4. Test a slash command: type `/graphify` to open the menu, or `/graphify-status` to check graph status.
+5. Test a tool by asking: "Use the graphify graph to explain how auth works in this codebase."
 
 ## Verify the extension without Graphify
 

package/extensions/index.ts

@@ -9,6 +9,8 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerGraphifyCommands } from "../src/commands/index.js";
+import { registerGraphifyMenuCommand } from "../src/commands/menu.js";
 import { GraphifyCoordinator } from "../src/coordinator.js";
 import { buildGraphifyHint, graphifyStatus } from "../src/graphify.js";
 import { registerGraphifyTools } from "../src/tools/index.js";
@@ -20,23 +22,8 @@ export default function (pi: ExtensionAPI) {
   const registeredToolNames = new Set<string>();
 
   // ── 1. Register slash commands synchronously ─────────────────────
-  pi.registerCommand("graphify-status", {
-    description: "Show Graphify graph status for the current project",
-    handler: async (_args, ctx) => {
-      const current = getCoordinator();
-      if (!current) {
-        ctx.ui.notify("Graphify is not initialized.", "warning");
-        return;
-      }
-
-      const status = await current.status({ cwd: ctx.cwd });
-      if (status.hasGraph && status.graphPath) {
-        ctx.ui.notify(`Graphify graph ready: ${status.graphPath}`, "info");
-      } else {
-        ctx.ui.notify("No Graphify graph found. Build one with `graphify .`.", "warning");
-      }
-    },
-  });
+  registerGraphifyCommands(pi, getCoordinator);
+  registerGraphifyMenuCommand(pi, getCoordinator);
 
   // ── 2. Initialize coordinator and register tools per session ───────
   // Tools are registered inside session_start so we can gate them by the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wwjd/pi-graphify",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Graphify knowledge graph integration for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "scripts": {
-    "test": "node --test --import tsx src/tools/tools.test.ts src/extensions/extension-load.test.ts",
+    "test": "node --test --import tsx src/tools/tools.test.ts src/commands/commands.test.ts src/commands/menu.test.ts src/extensions/extension-load.test.ts",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "format": "biome format --write .",

package/src/commands/affected.ts

@@ -0,0 +1,63 @@
+/**
+ * /graphify-affected — show files and nodes affected by changes to given files.
+ */
+
+import { resolve } from "node:path";
+import type { GraphifyCapabilities } from "../backends/types.js";
+import { formatResultForCommand } from "./format.js";
+import { notifyCommandError, requireCoordinatorWithCapability } from "./helpers.js";
+import { splitArgs, usageError } from "./parse.js";
+import type { CommandDefinition, CommandExecutor } from "./types.js";
+
+const FEATURE: keyof GraphifyCapabilities = "affected";
+const AFFECTED_USAGE = "<file> [file...]";
+
+const executeAffected: CommandExecutor = async (ctx, getCoordinator, args) => {
+  if (!ctx.hasUI) return;
+
+  const coordinator = requireCoordinatorWithCapability(
+    ctx,
+    getCoordinator,
+    FEATURE,
+    "The installed Graphify version does not support affected analysis.",
+  );
+  if (!coordinator) return;
+
+  try {
+    const files = parseAffectedArgs(ctx.cwd, args);
+    const result = await coordinator.affected({ cwd: ctx.cwd, files });
+    ctx.ui.notify(formatResultForCommand(result), "info");
+  } catch (error) {
+    notifyCommandError(ctx, error);
+  }
+};
+
+export const affectedCommand: CommandDefinition = {
+  name: "graphify-affected",
+  label: "Show affected",
+  description: "Show files and nodes affected by changes to given files",
+  feature: FEATURE,
+  usage: AFFECTED_USAGE,
+  argMode: "input",
+  prompt: "Files to analyze",
+  placeholder: "src/index.ts src/utils.ts",
+  execute: executeAffected,
+};
+
+function parseAffectedArgs(cwd: string, args: string): string[] {
+  const tokens = splitArgs(args);
+  if (tokens.length === 0) {
+    throw usageError("graphify-affected", AFFECTED_USAGE);
+  }
+
+  return tokens.map((file) => resolveFile(cwd, file));
+}
+
+function resolveFile(cwd: string, file: string): string {
+  const absolute = resolve(cwd, file);
+  const normalizedCwd = resolve(cwd);
+  if (!absolute.startsWith(normalizedCwd)) {
+    throw new Error(`Invalid file path: ${file} is outside the project directory.`);
+  }
+  return absolute;
+}

package/src/commands/build.ts

@@ -0,0 +1,77 @@
+/**
+ * /graphify-build — build or update the Graphify knowledge graph.
+ */
+
+import type { GraphifyCapabilities } from "../backends/types.js";
+import { formatResultForCommand } from "./format.js";
+import { notifyCommandError, requireCoordinatorWithCapability } from "./helpers.js";
+import { parseBooleanFlag, splitArgs, usageError } from "./parse.js";
+import type { CommandDefinition, CommandExecutor } from "./types.js";
+
+const FEATURE: keyof GraphifyCapabilities = "build";
+const BUILD_USAGE = "[--code-only] [--update] [--directed]";
+
+const executeBuild: CommandExecutor = async (ctx, getCoordinator, args) => {
+  if (!ctx.hasUI) return;
+
+  const coordinator = requireCoordinatorWithCapability(
+    ctx,
+    getCoordinator,
+    FEATURE,
+    "The installed Graphify version does not support graph builds.",
+  );
+  if (!coordinator) return;
+
+  if (!ctx.isProjectTrusted()) {
+    ctx.ui.notify("Project trust is required to build the Graphify graph.", "warning");
+    return;
+  }
+
+  try {
+    const { codeOnly, update, directed } = parseBuildArgs(args);
+    const result = await coordinator.build({
+      cwd: ctx.cwd,
+      codeOnly,
+      update,
+      directed,
+    });
+    ctx.ui.notify(formatResultForCommand(result), "info");
+  } catch (error) {
+    notifyCommandError(ctx, error);
+  }
+};
+
+export const buildCommand: CommandDefinition = {
+  name: "graphify-build",
+  label: "Build graph",
+  description: "Build or incrementally update the Graphify knowledge graph",
+  feature: FEATURE,
+  usage: BUILD_USAGE,
+  argMode: "flags",
+  prompt: "Build graph (optional flags)",
+  placeholder: "--code-only --update --directed",
+  execute: executeBuild,
+};
+
+interface ParsedBuildArgs {
+  codeOnly: boolean | undefined;
+  update: boolean | undefined;
+  directed: boolean | undefined;
+}
+
+function parseBuildArgs(args: string): ParsedBuildArgs {
+  const tokens = splitArgs(args);
+  let result = parseBooleanFlag(tokens, "code-only", true);
+  const codeOnly = result.value;
+  result = parseBooleanFlag(result.rest, "update", true);
+  const update = result.value;
+  result = parseBooleanFlag(result.rest, "directed", true);
+  const directed = result.value;
+
+  const unknown = result.rest.find((t) => t.startsWith("--"));
+  if (unknown || result.rest.length > 0) {
+    throw usageError("graphify-build", BUILD_USAGE);
+  }
+
+  return { codeOnly, update, directed };
+}