agentrace 0.1.0 → 0.1.2

package/dist/commands/mcp-server.js

@@ -1,480 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import { patchMake, patchToText } from "diff-match-patch-es";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-import { PlanDocumentClient } from "../mcp/plan-document-client.js";
-// Read session_id and tool_use_id from file written by PreToolUse hook
-function getSessionInfoFromFile() {
-    try {
-        const sessionFile = path.join(os.homedir(), ".agentrace", "current-session.json");
-        if (fs.existsSync(sessionFile)) {
-            const content = fs.readFileSync(sessionFile, "utf-8");
-            const data = JSON.parse(content);
-            return {
-                session_id: data.session_id,
-                tool_use_id: data.tool_use_id,
-            };
-        }
-    }
-    catch {
-        // Ignore errors, return empty object
-    }
-    return {};
-}
-// Tool schemas
-const SearchPlansSchema = z.object({
-    git_remote_url: z.string().optional().describe("Git remote URL to filter by project"),
-    status: z.string().optional().describe("Comma-separated statuses to filter (e.g., 'planning,implementation')"),
-    description: z.string().optional().describe("Partial match search on plan description"),
-});
-const ReadPlanSchema = z.object({
-    id: z.string().describe("Plan document ID"),
-});
-const CreatePlanSchema = z.object({
-    description: z.string().describe("Short description of the plan"),
-    body: z.string().describe("Plan content in Markdown format"),
-});
-const UpdatePlanSchema = z.object({
-    id: z.string().describe("Plan document ID"),
-    body: z.string().describe("Updated plan content in Markdown format"),
-    message: z.string().optional().describe("One-line description of what was changed"),
-});
-const SetPlanStatusSchema = z.object({
-    id: z.string().describe("Plan document ID"),
-    status: z.enum(["scratch", "draft", "planning", "pending", "ready", "implementation", "complete"]).describe("New status for the plan"),
-    message: z.string().optional().describe("One-line description of why the status is being changed"),
-});
-const GetPlanCommentsSchema = z.object({
-    plan_id: z.string().describe("Plan document ID"),
-    status: z.enum(["active", "resolved", "outdated", "all"]).optional().describe("Filter comments by status. Defaults to showing all comments."),
-});
-const AddPlanCommentSchema = z.object({
-    plan_id: z.string().describe("Plan document ID"),
-    target_text: z.string().describe("The text in the plan body that this comment refers to"),
-    content: z.string().describe("The comment content"),
-});
-const ResolvePlanCommentSchema = z.object({
-    plan_id: z.string().describe("Plan document ID"),
-    thread_id: z.string().describe("Comment thread ID to resolve"),
-});
-// Tool descriptions with usage guidance
-const TOOL_DESCRIPTIONS = {
-    search_plans: `Search plan documents with filtering options.
-
-WHEN TO USE:
-- When you need to check existing plans for the current repository
-- When the user asks about available plans or implementation documents
-- Before creating a new plan to avoid duplicates
-- When searching for plans by status (e.g., find all plans in 'scratch' status)
-- When searching for plans by description keyword`,
-    read_plan: `Read a plan document by ID.
-
-WHEN TO USE:
-- When the user asks you to check or review a specific plan by ID
-- When you need to understand an existing plan before making changes
-- When the user references a plan ID in their request
-
-IMPORTANT - HANDLING COMMENTS:
-- The response includes 'active_comments_count' showing how many unresolved comments exist
-- If the plan is in 'planning' status AND has active comments (active_comments_count > 0):
-  - You SHOULD use get_plan_comments to read the comments
-  - Consider the feedback in the comments and reflect it in your plan updates
-  - Comments represent team feedback that should be addressed before moving to ready`,
-    create_plan: `Create a new plan document to record implementation or design plans.
-
-WHEN TO USE:
-- ALWAYS use this when you create a design or implementation plan
-- When entering plan mode and documenting your approach
-- When the user asks you to save or persist a plan
-- When planning significant features, refactoring, or architectural changes
-
-The plan will be saved to AgenTrace server and can be reviewed by the team.
-The project is automatically determined from the session's git repository.`,
-    update_plan: `Update an existing plan document.
-
-WHEN TO USE:
-- When the user asks you to modify a specific plan by ID
-- When implementation details change and the plan needs updating
-- When you need to add progress notes or completion status to a plan
-
-Changes are tracked with diff patches for history.`,
-    set_plan_status: `Set the status of a plan document.
-
-WHEN TO USE:
-- When transitioning a plan from planning to implementation phase
-- When marking a plan as complete after finishing the work
-- When the user explicitly asks to change the status of a plan
-
-Available statuses:
-- scratch: Initial rough notes, starting point for discussion with AI
-- draft: Plan not yet fully considered (optional intermediate status)
-- planning: Plan is being designed/refined through discussion
-- pending: Waiting for approval or blocked
-- ready: Plan is finalized and ready for implementation (awaiting review/approval to start)
-- implementation: Active development is in progress
-- complete: The work described in the plan is finished
-
-BASIC FLOW: scratch → planning → ready → implementation → complete
-(draft and pending are optional auxiliary statuses)
-
-STATUS TRANSITION GUIDELINES:
-- scratch → planning: When you read a scratch plan (usually written by human), review its content and rewrite it into a more concrete plan, then change status to planning
-- planning → ready: When the plan is finalized after discussion, change status to ready
-- ready → implementation: When you start working on the plan, change status to implementation
-- implementation → complete: When all work described in the plan is finished, change status to complete
-
-CAUTION:
-- When a plan is in "implementation" status, someone else might already be working on it. Check with the team before starting work on such plans.`,
-    get_plan_comments: `Get comments for a plan document.
-
-WHEN TO USE:
-- When you need to see feedback or discussions on a specific plan
-- When reviewing a plan that others have commented on
-- Before making changes to understand any concerns or suggestions
-
-Returns comments with their status (active, resolved, or outdated).`,
-    add_plan_comment: `Add a comment to a specific location in a plan.
-
-WHEN TO USE:
-- When you want to provide feedback on a specific part of a plan
-- When you have a question or suggestion about the plan content
-- When reviewing a plan and want to leave notes for the team
-
-The comment is anchored to specific text in the plan body.`,
-    resolve_plan_comment: `Resolve a comment thread on a plan.
-
-WHEN TO USE:
-- When you have addressed the feedback in a comment
-- When the issue raised in the comment has been fixed
-- When the comment is no longer relevant after plan updates
-
-Resolving a comment marks it as handled, keeping it visible but indicating it's been addressed.`,
-};
-export async function mcpServerCommand() {
-    const server = new McpServer({
-        name: "agentrace",
-        version: "1.0.0",
-        description: `AgenTrace Plan Document Management Server.
-
-This server provides tools to manage implementation and design plans.
-Plans are stored on the AgenTrace server and can be reviewed by the team.
-
-IMPORTANT GUIDELINES:
-- When you create a design or implementation plan, ALWAYS save it using create_plan
-- When the user asks you to check or modify a plan by ID, use the appropriate tool
-- Plans help track what you're working on and enable team collaboration`,
-    });
-    let client = null;
-    function getClient() {
-        if (!client) {
-            // Use CLAUDE_PROJECT_DIR to find local config if available
-            const projectDir = process.env.CLAUDE_PROJECT_DIR;
-            client = new PlanDocumentClient(projectDir);
-        }
-        return client;
-    }
-    // search_plans tool
-    server.tool("search_plans", TOOL_DESCRIPTIONS.search_plans, SearchPlansSchema.shape, async (args) => {
-        try {
-            const plans = await getClient().searchPlans({
-                gitRemoteUrl: args.git_remote_url,
-                status: args.status,
-                description: args.description,
-            });
-            if (plans.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No plans found matching the search criteria.",
-                        },
-                    ],
-                };
-            }
-            const planList = plans.map((plan) => ({
-                id: plan.id,
-                description: plan.description,
-                status: plan.status,
-                active_comments_count: plan.active_comments_count,
-                git_remote_url: plan.project?.canonical_git_repository || null,
-                url: plan.url || null,
-                updated_at: plan.updated_at,
-                collaborators: plan.collaborators.map((c) => c.display_name).join(", "),
-            }));
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(planList, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // read_plan tool
-    server.tool("read_plan", TOOL_DESCRIPTIONS.read_plan, ReadPlanSchema.shape, async (args) => {
-        try {
-            const plan = await getClient().getPlan(args.id);
-            let text = `# ${plan.description}\n\nStatus: ${plan.status}\nActive Comments: ${plan.active_comments_count}\n\n${plan.body}`;
-            if (plan.url) {
-                text += `\n\n---\nURL: ${plan.url}`;
-            }
-            // Add reminder if there are active comments on a planning status plan
-            if (plan.status === "planning" && plan.active_comments_count > 0) {
-                text += `\n\n---\n⚠️ This plan has ${plan.active_comments_count} active comment(s). Use get_plan_comments to review them and consider the feedback.`;
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // create_plan tool
-    server.tool("create_plan", TOOL_DESCRIPTIONS.create_plan, CreatePlanSchema.shape, async (args) => {
-        try {
-            // Read session_id and tool_use_id from file written by PreToolUse hook
-            const sessionInfo = getSessionInfoFromFile();
-            const plan = await getClient().createPlan({
-                description: args.description,
-                body: args.body,
-                claude_session_id: sessionInfo.session_id,
-                tool_use_id: sessionInfo.tool_use_id,
-            });
-            let text = `Plan created successfully.\n\nID: ${plan.id}\nDescription: ${plan.description}`;
-            if (plan.url) {
-                text += `\nURL: ${plan.url}`;
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // update_plan tool
-    server.tool("update_plan", TOOL_DESCRIPTIONS.update_plan, UpdatePlanSchema.shape, async (args) => {
-        try {
-            // Read session_id and tool_use_id from file written by PreToolUse hook
-            const sessionInfo = getSessionInfoFromFile();
-            // Get current plan to compute patch
-            const currentPlan = await getClient().getPlan(args.id);
-            // Compute patch using diff-match-patch
-            const patches = patchMake(currentPlan.body, args.body);
-            const patchText = patchToText(patches);
-            const plan = await getClient().updatePlan(args.id, {
-                body: args.body,
-                patch: patchText,
-                message: args.message,
-                claude_session_id: sessionInfo.session_id,
-                tool_use_id: sessionInfo.tool_use_id,
-            });
-            let text = `Plan updated successfully.\n\nID: ${plan.id}\nDescription: ${plan.description}`;
-            if (plan.url) {
-                text += `\nURL: ${plan.url}`;
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // set_plan_status tool
-    server.tool("set_plan_status", TOOL_DESCRIPTIONS.set_plan_status, SetPlanStatusSchema.shape, async (args) => {
-        try {
-            const plan = await getClient().setStatus(args.id, args.status, args.message);
-            let text = `Plan status updated successfully.\n\nID: ${plan.id}\nDescription: ${plan.description}\nStatus: ${plan.status}`;
-            if (plan.url) {
-                text += `\nURL: ${plan.url}`;
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // get_plan_comments tool
-    server.tool("get_plan_comments", TOOL_DESCRIPTIONS.get_plan_comments, GetPlanCommentsSchema.shape, async (args) => {
-        try {
-            const threads = await getClient().getThreads(args.plan_id, args.status);
-            if (threads.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No comments found for this plan.",
-                        },
-                    ],
-                };
-            }
-            const threadList = threads.map((thread) => ({
-                id: thread.id,
-                target_text: thread.target_text,
-                status: thread.status,
-                position: thread.position ? {
-                    start_line: thread.position.start_line,
-                    start_column: thread.position.start_column,
-                    end_line: thread.position.end_line,
-                    end_column: thread.position.end_column,
-                    found: thread.position.found,
-                } : null,
-                messages: thread.messages.map((msg) => ({
-                    id: msg.id,
-                    user_name: msg.user_name,
-                    content: msg.content,
-                    created_at: msg.created_at,
-                })),
-                created_at: thread.created_at,
-            }));
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(threadList, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // add_plan_comment tool
-    server.tool("add_plan_comment", TOOL_DESCRIPTIONS.add_plan_comment, AddPlanCommentSchema.shape, async (args) => {
-        try {
-            const thread = await getClient().createThread(args.plan_id, {
-                target_text: args.target_text,
-                context_before: "",
-                context_after: "",
-                content: args.content,
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Comment added successfully.\n\nThread ID: ${thread.id}\nStatus: ${thread.status}\nTarget: "${thread.target_text}"`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // resolve_plan_comment tool
-    server.tool("resolve_plan_comment", TOOL_DESCRIPTIONS.resolve_plan_comment, ResolvePlanCommentSchema.shape, async (args) => {
-        try {
-            const thread = await getClient().resolveThread(args.plan_id, args.thread_id);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Comment resolved successfully.\n\nThread ID: ${thread.id}\nStatus: ${thread.status}\nTarget: "${thread.target_text}"`,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-    // Start the server with stdio transport
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-}

package/dist/commands/off.d.ts

@@ -1,4 +0,0 @@
-export interface OffOptions {
-    local?: boolean;
-}
-export declare function offCommand(options?: OffOptions): Promise<void>;

package/dist/commands/off.js

@@ -1,46 +0,0 @@
-import { uninstallHooks, uninstallMcpServer, uninstallPreToolUseHook } from "../hooks/installer.js";
-import { loadConfig, loadConfigWithFallback } from "../config/manager.js";
-export async function offCommand(options = {}) {
-    const projectDir = options.local ? process.cwd() : undefined;
-    // Check if config exists (local config takes precedence if --local is specified)
-    const config = options.local ? loadConfigWithFallback(projectDir) : loadConfig();
-    if (!config) {
-        console.log("AgenTrace is not configured. Run 'npx agentrace init' first.");
-        return;
-    }
-    if (options.local) {
-        console.log("[Local Mode] Disabling hooks/MCP for this project only\n");
-    }
-    const result = uninstallHooks({
-        local: options.local,
-        projectDir,
-    });
-    if (result.success) {
-        console.log(`✓ Hooks disabled. Your credentials are still saved.`);
-        console.log(`  Run 'npx agentrace on${options.local ? " --local" : ""}' to re-enable.`);
-    }
-    else {
-        console.error(`✗ ${result.message}`);
-    }
-    // Remove PreToolUse hook
-    const preToolUseResult = uninstallPreToolUseHook({
-        local: options.local,
-        projectDir,
-    });
-    if (preToolUseResult.success) {
-        console.log(`✓ ${preToolUseResult.message}`);
-    }
-    else {
-        console.error(`✗ ${preToolUseResult.message}`);
-    }
-    const mcpResult = uninstallMcpServer({
-        local: options.local,
-        projectDir,
-    });
-    if (mcpResult.success) {
-        console.log(`✓ ${mcpResult.message}`);
-    }
-    else {
-        console.error(`✗ ${mcpResult.message}`);
-    }
-}

package/dist/commands/on.d.ts

@@ -1,5 +0,0 @@
-export interface OnOptions {
-    dev?: boolean;
-    local?: boolean;
-}
-export declare function onCommand(options?: OnOptions): Promise<void>;

package/dist/commands/on.js

@@ -1,69 +0,0 @@
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { installHooks, installMcpServer, installPreToolUseHook } from "../hooks/installer.js";
-import { loadConfig, loadConfigWithFallback } from "../config/manager.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-export async function onCommand(options = {}) {
-    const projectDir = options.local ? process.cwd() : undefined;
-    // Check if config exists (local config takes precedence if --local is specified)
-    const config = options.local ? loadConfigWithFallback(projectDir) : loadConfig();
-    if (!config) {
-        console.log("AgenTrace is not configured. Run 'npx agentrace init' first.");
-        return;
-    }
-    if (options.local) {
-        console.log("[Local Mode] Enabling hooks/MCP for this project only\n");
-    }
-    // Determine hook command
-    let hookCommand;
-    if (options.dev) {
-        // Use local CLI path for development
-        const cliRoot = path.resolve(__dirname, "../..");
-        const indexPath = path.join(cliRoot, "src/index.ts");
-        hookCommand = `npx tsx ${indexPath} send`;
-    }
-    const result = installHooks({
-        command: hookCommand,
-        local: options.local,
-        projectDir,
-    });
-    if (result.success) {
-        console.log(`✓ Hooks enabled. Session data will be sent to ${config.server_url}`);
-    }
-    else {
-        console.error(`✗ ${result.message}`);
-    }
-    // Install MCP server
-    let mcpCommand;
-    let mcpArgs;
-    if (options.dev) {
-        const cliRoot = path.resolve(__dirname, "../..");
-        const indexPath = path.join(cliRoot, "src/index.ts");
-        mcpCommand = "npx";
-        mcpArgs = ["tsx", indexPath, "mcp-server"];
-    }
-    const mcpResult = installMcpServer({
-        command: mcpCommand,
-        args: mcpArgs,
-        local: options.local,
-        projectDir,
-    });
-    if (mcpResult.success) {
-        console.log(`✓ ${mcpResult.message}`);
-    }
-    else {
-        console.error(`✗ ${mcpResult.message}`);
-    }
-    // Install PreToolUse hook for session_id injection
-    const preToolUseResult = installPreToolUseHook({
-        local: options.local,
-        projectDir,
-    });
-    if (preToolUseResult.success) {
-        console.log(`✓ ${preToolUseResult.message}`);
-    }
-    else {
-        console.error(`✗ ${preToolUseResult.message}`);
-    }
-}

package/dist/commands/send.d.ts

@@ -1,12 +0,0 @@
-/**
- * Hook-based send command.
- * Reads session info from stdin (provided by Claude Code hooks).
- */
-export declare function sendCommand(): Promise<void>;
-/**
- * Manual send command.
- * Finds session file by ID and sends to server.
- */
-export declare function sendManualCommand(options: {
-    sessionId: string;
-}): Promise<void>;