boomtick-cli 0.2.1__py3-none-any.whl

dev_tools/dist/tools/repo.get_package_scripts.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { config } from "../config.js";
+export const GetPackageScriptsInputSchema = z.object({
+    filter: z.string().optional(),
+});
+export async function getPackageScriptsHandler(args) {
+    GetPackageScriptsInputSchema.parse(args);
+    const packageJsonPath = path.join(config.repoPath, "package.json");
+    try {
+        const content = await fs.readFile(packageJsonPath, "utf-8");
+        let pkg;
+        try {
+            pkg = JSON.parse(content);
+        }
+        catch (e) {
+            throw new Error(`Malformed package.json: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        let scripts = pkg.scripts || {};
+        if (args.filter) {
+            const filtered = {};
+            for (const [name, cmd] of Object.entries(scripts)) {
+                if (name.includes(args.filter)) {
+                    filtered[name] = cmd;
+                }
+            }
+            scripts = filtered;
+        }
+        return { scripts };
+    }
+    catch (error) {
+        throw new Error(`Failed to read package.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}

dev_tools/dist/tools/repo.get_package_scripts.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi } from "vitest";
+import { getPackageScriptsHandler } from "./repo.get_package_scripts.js";
+import fs from "fs/promises";
+vi.mock("fs/promises");
+describe("repo.get_package_scripts", () => {
+    it("should return scripts from package.json", async () => {
+        const mockPkg = {
+            scripts: { test: "vitest" }
+        };
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockPkg));
+        const result = await getPackageScriptsHandler({});
+        expect(result.scripts.test).toBe("vitest");
+    });
+    it("should handle missing scripts", async () => {
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({}));
+        const result = await getPackageScriptsHandler({});
+        expect(result.scripts).toEqual({});
+    });
+    it("should throw error when file not found", async () => {
+        vi.mocked(fs.readFile).mockRejectedValue(new Error("File not found"));
+        await expect(getPackageScriptsHandler({})).rejects.toThrow("Failed to read package.json: File not found");
+    });
+    it("should filter scripts by pattern", async () => {
+        const mockPkg = {
+            scripts: {
+                test: "vitest",
+                build: "vite build",
+                "test:ui": "vitest --ui"
+            }
+        };
+        vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockPkg));
+        const result = await getPackageScriptsHandler({ filter: "test" });
+        expect(result.scripts).toEqual({
+            test: "vitest",
+            "test:ui": "vitest --ui"
+        });
+        expect(result.scripts.build).toBeUndefined();
+    });
+});

dev_tools/dist/tools/repo.get_route_map.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+import { config } from "../config.js";
+import path from "path";
+export const GetRouteMapInputSchema = z.object({
+    includeStatic: z.boolean().optional(),
+});
+export async function getRouteMapHandler(args) {
+    GetRouteMapInputSchema.parse(args);
+    // Logic based on tech-dancer repo structure: src/config/routes.ts and content/
+    const routesPath = path.join(config.repoPath, "src/config/routes.ts");
+    // For simplicity in MVP, we'll try to find routes by listing content files
+    // and reading the main routes file if it exists.
+    let routeMap = {};
+    try {
+        const gitFiles = await runCommand("git", ["ls-files", "content/"]);
+        const contentFiles = gitFiles.stdout.trim().split("\n");
+        for (const file of contentFiles) {
+            if (file.endsWith(".md")) {
+                const slug = path.basename(file, ".md");
+                if (file.includes("/posts/")) {
+                    routeMap[`/blog/${slug}`] = file;
+                }
+                else if (file.includes("/resources/")) {
+                    routeMap[`/resources/${slug}`] = file;
+                }
+            }
+        }
+    }
+    catch (error) {
+        // If no content files, that's fine
+    }
+    if (args.includeStatic) {
+        routeMap["/favicon.ico"] = "public/favicon.ico";
+    }
+    return { routeMap };
+}

dev_tools/dist/tools/repo.logs.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import { runTDCli } from "../lib/td-cli.js";
+export const RepoLogsInputSchema = z.object({
+    prNumber: z.number(),
+    grep: z.string().optional(),
+});
+export async function repoLogsHandler(args) {
+    const params = ["repo", "logs", args.prNumber.toString()];
+    if (args.grep) {
+        params.push("--grep", args.grep);
+    }
+    const output = await runTDCli(params);
+    return {
+        logs: output.logs || (output.data ? output.data.logs : undefined)
+    };
+}

dev_tools/dist/tools/repo.read_agent_context.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import fs from "fs/promises";
+import path from "path";
+import { config } from "../config.js";
+export const ReadAgentContextInputSchema = z.object({});
+export async function readAgentContextHandler(_args) {
+    const contextPath = path.join(config.repoPath, ".agent-context.json");
+    try {
+        const content = await fs.readFile(contextPath, "utf-8");
+        const parsed = JSON.parse(content);
+        return {
+            status: "success",
+            ...parsed
+        };
+    }
+    catch (e) {
+        console.error("Failed to read agent context:", e.message);
+        throw new Error(`Failed to read agent context from ${contextPath}. Ensure it exists by running 'td-cli context-warm'.`);
+    }
+}

dev_tools/dist/tools/repo.read_ci_logs.js

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { runTDCli } from "../lib/td-cli.js";
+export const ReadCiLogsInputSchema = z.object({
+    prNumber: z.number(),
+    all: z.boolean().optional(),
+});
+export async function readCiLogsHandler(args) {
+    const params = ["repo", "ci-logs", args.prNumber.toString()];
+    if (args.all) {
+        params.push("--all");
+    }
+    const output = await runTDCli(params);
+    return {
+        checks: output.checks,
+        failedChecks: output.failedChecks,
+        logs: output.logs
+    };
+}

dev_tools/dist/tools/repo.run_lighthouse.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const RunLighthouseInputSchema = z.object({
+    route: z.string().optional().default("/"),
+    worktreePath: z.string().optional(),
+});
+export async function runLighthouseHandler(args) {
+    const results = await runCommand("pnpm", ["lhci", "autorun", "--json"], { cwd: args.worktreePath });
+    let summary = {};
+    const failures = [];
+    try {
+        // Attempt to parse summary from LHCI output if available
+        // For MVP, we'll provide a structured placeholder if actual JSON isn't present
+        if (results.stdout.includes("{")) {
+            const possibleJson = results.stdout.substring(results.stdout.indexOf("{"));
+            summary = JSON.parse(possibleJson);
+        }
+        else {
+            summary = {
+                performance: 0,
+                accessibility: 0,
+                bestPractices: 0,
+                seo: 0
+            };
+        }
+    }
+    catch (e) {
+        failures.push("Failed to parse Lighthouse report");
+    }
+    return {
+        success: results.exitCode === 0,
+        route: args.route,
+        summary,
+        failures,
+        command: results.command
+    };
+}

dev_tools/dist/tools/repo.run_playwright.js

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const RunPlaywrightInputSchema = z.object({
+    grep: z.string().optional(),
+    worktreePath: z.string().optional(),
+});
+export async function runPlaywrightHandler(args) {
+    const tdArgs = ["repo", "run-playwright"];
+    if (args.grep) {
+        tdArgs.push("--grep", args.grep);
+    }
+    if (args.worktreePath) {
+        tdArgs.push("--worktree", args.worktreePath);
+    }
+    const result = await runCommand("td-cli", tdArgs);
+    if (result.exitCode !== 0) {
+        // Playwright might exit with non-zero if tests fail, but our td-cli should ideally handle it
+        // and return a JSON with success: false.
+    }
+    const output = JSON.parse(result.stdout);
+    if (output.status === "error") {
+        throw new Error(`Failed to run Playwright: ${output.message}`);
+    }
+    return {
+        success: output.success,
+        command: output.command,
+        failedTests: output.failedTests
+    };
+}

dev_tools/dist/tools/repo.run_tests.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { runCommand } from "../lib/shell.js";
+export const RunTestsInputSchema = z.object({
+    commands: z.array(z.string()).optional(),
+    timeoutSeconds: z.number().optional().default(300),
+    worktreePath: z.string().optional(),
+});
+export async function runTestsHandler(args) {
+    const commands = args.commands || [
+        "pnpm install --frozen-lockfile",
+        "pnpm lint",
+        "pnpm test",
+        "pnpm build"
+    ];
+    const results = [];
+    let success = true;
+    for (const fullCmd of commands) {
+        const [cmd, ...cmdArgs] = fullCmd.split(" ");
+        try {
+            const res = await runCommand(cmd, cmdArgs, {
+                cwd: args.worktreePath,
+                timeout: args.timeoutSeconds * 1000
+            });
+            results.push(res);
+            if (res.exitCode !== 0) {
+                success = false;
+                break;
+            }
+        }
+        catch (e) {
+            success = false;
+            results.push({
+                command: fullCmd,
+                stdout: "",
+                stderr: e instanceof Error ? e.message : String(e),
+                exitCode: 1,
+                durationMs: 0
+            });
+            break;
+        }
+    }
+    return { success, results };
+}

dev_tools/dist/tools/types.js

@@ -0,0 +1 @@
+export {};

dev_tools/get_ai_context.py

@@ -0,0 +1,63 @@
+# pylint: disable=missing-docstring,unused-import,no-value-for-parameter
+import sys
+from typing import Any, Dict, List
+import json
+
+
+import click
+from dev_tools.services.dependency_graph import DependencyGraph
+from dev_tools.services.vector_store import VectorStore
+
+
+def get_context(filepath: str, diff_text: str, graph: DependencyGraph, store: VectorStore, n_results: int = 3):
+    context: Dict[str, Any] = {"path": filepath, "dependencies": [], "dependents": [], "semantic": []}
+
+    if not isinstance(filepath, str) or not isinstance(diff_text, str) or not filepath.strip() or not diff_text.strip():
+        return context
+
+    context["dependencies"] = graph.get_dependencies(filepath)
+    context["dependents"] = graph.get_dependents(filepath)
+
+    try:
+        # Use diff_text for semantic search
+        results = store.query(diff_text, n_results=n_results)
+        for res in results:
+            if res["metadata"].get("path") != filepath:
+                context["semantic"].append({"path": res["metadata"].get("path"), "document": res["document"]})
+    except Exception as e:
+        print(f"Error querying vector store: {e}", file=sys.stderr)
+
+    return context
+
+
+@click.command()
+@click.argument("input_file", type=click.File("r"), default="-")
+def main(input_file):
+    """Retrieve dependency and semantic context for a set of changed files."""
+    try:
+        input_data = json.load(input_file)
+    except Exception as e:
+        click.echo(f"Error parsing input JSON: {e}", err=True)
+        sys.exit(1)
+
+    files_data: List[Dict[str, Any]] = input_data.get("files", [])
+    if not files_data:
+        print(json.dumps([]))
+        sys.exit(0)
+
+    # Initialize services once
+    graph = DependencyGraph()
+    store = VectorStore()
+
+    results: List[Dict[str, Any]] = []
+    for item in files_data:
+        filepath = item.get("path")
+        diff_text = item.get("diff")
+        if filepath and diff_text:
+            results.append(get_context(filepath, diff_text, graph, store))
+
+    click.echo(json.dumps(results))
+
+
+if __name__ == "__main__":
+    main()

dev_tools/handlers/__init__.py

@@ -0,0 +1 @@
+# pylint: disable=missing-docstring

dev_tools/handlers/command_handler.py

@@ -0,0 +1,69 @@
+# pylint: disable=line-too-long,missing-docstring,no-else-return,too-few-public-methods,unused-argument
+from typing import Any, Dict, Optional
+
+
+class CommandHandler:
+    def __init__(self, orchestrator):
+        self.orchestrator = orchestrator
+
+    def handle(self, pr_number: int, command_text: str, comment_id: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Parses and dispatches slash commands.
+        """
+        command = command_text.strip().lower()
+
+        if command.startswith("/ai-review"):
+            return self._handle_ai_review(pr_number)
+        elif command.startswith("/ai-fix"):
+            return self._handle_ai_fix(pr_number)
+
+        return {"status": "ignored", "message": f"Unknown command: {command}"}
+
+    def _handle_ai_review(self, pr_number: int) -> Dict[str, Any]:
+        review_data = self.orchestrator.review_pr(pr_number)
+        recommendation = review_data.get("recommendation", "COMMENT")
+
+        # Map recommendation to GH event
+        event = "COMMENT"
+        if recommendation == "Approved":
+            event = "APPROVE"
+        elif recommendation == "Not Approved":
+            event = "REQUEST_CHANGES"
+
+        comment_body = f"## 🤖 AI Code Review\n\n{review_data.get('reviewComment', 'No comment provided.')}\n\n**Recommendation:** {recommendation}"
+
+        self.orchestrator.github.create_review(pr_number, comment_body, [], event)
+
+        return {
+            "status": "success",
+            "message": f"Submitted {event} review for PR #{pr_number}",
+            "review": review_data,
+        }
+
+    def _handle_ai_fix(self, pr_number: int) -> Dict[str, Any]:
+        # First, ensure we have the conflict files
+        conflict_files = self.orchestrator.find_conflict_files()
+        if not conflict_files:
+            return {
+                "status": "error",
+                "message": "No merge conflicts detected locally. Ensure you have merged the base branch and markers are present.",
+            }
+
+        results = [(f, self.orchestrator.resolve_conflict(f)) for f in conflict_files]
+        resolved = [f for f, success in results if success]
+        failed = [f for f, success in results if not success]
+
+        if failed:
+            msg = f"Failed to resolve conflicts in: {', '.join(failed)}"
+            return {
+                "status": "partial_success" if resolved else "error",
+                "message": msg,
+                "resolved": resolved,
+                "failed": failed,
+            }
+
+        return {
+            "status": "success",
+            "message": f"Successfully resolved conflicts in {len(resolved)} files.",
+            "resolved": resolved,
+        }

dev_tools/mcp_server.py

@@ -0,0 +1,36 @@
+"""
+MCP Server management for boomtick-cli.
+"""
+import subprocess
+from dev_tools.utils import resolve_resource_path
+
+class NodeNotFoundError(RuntimeError):
+    """Raised when Node.js is not found on the PATH."""
+
+
+def start_mcp_server():
+    """
+    Spawns the TypeScript MCP server as a Node.js subprocess.
+    """
+    try:
+        server_js = resolve_resource_path("dist/index.js")
+    except FileNotFoundError as e:
+        raise RuntimeError(
+            f"MCP server source file not found: {e}. "
+            "Ensure the package is correctly installed with bundled JS artifacts."
+        ) from e
+
+    # Spawn Node subprocess to communicate via standard I/O pipes
+    try:
+        return subprocess.Popen(
+            ["node", server_js],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+    except FileNotFoundError as e:
+        raise NodeNotFoundError(
+            "Node.js is required to run the MCP server but was not found on the PATH. "
+            "Please install Node.js 24+ and try again."
+        ) from e