frappe-builder 1.1.0-dev.10

package/tools/frappe-context7.ts

@@ -0,0 +1,70 @@
+import { execa } from "execa";
+
+export interface FrappeDocsArgs {
+  topic: string;
+  version?: string;
+}
+
+export interface FrappeDocsResult {
+  snippet?: string;
+  topic?: string;
+  source?: "context7";
+  error?: string;
+  fallback?: string;
+}
+
+const CONTEXT7_UNAVAILABLE: FrappeDocsResult = {
+  error: "context7 unavailable",
+  fallback: "search frappe.io manually",
+};
+
+/**
+ * Retrieves compressed Frappe/ERPNext documentation via context7 MCP subprocess.
+ * Raw web content never enters the LLM context — only the compressed snippet is returned.
+ * Returns a graceful error on any failure (timeout, MCP unavailable, not found).
+ * Never throws.
+ *
+ * Flow:
+ *   1. Resolve Frappe library ID via context7 resolve-library-id
+ *   2. Fetch compressed docs for topic via context7 get-library-docs
+ */
+export async function getFrappeDocs({ topic, version }: FrappeDocsArgs): Promise<FrappeDocsResult> {
+  try {
+    // Step 1: resolve Frappe library ID
+    const libraryName = version ? `frappe@${version}` : "frappe";
+    const resolveResult = await execa(
+      "mcp2cli",
+      ["context7", "resolve-library-id", "--libraryName", libraryName],
+      { timeout: 10_000 }
+    );
+
+    let libraryId: string;
+    try {
+      const parsed = JSON.parse(resolveResult.stdout) as { libraryId?: string };
+      if (!parsed.libraryId) return CONTEXT7_UNAVAILABLE;
+      libraryId = parsed.libraryId;
+    } catch {
+      return CONTEXT7_UNAVAILABLE;
+    }
+
+    // Step 2: fetch compressed docs for topic (~90% token reduction via 5000 token limit)
+    const docsResult = await execa(
+      "mcp2cli",
+      [
+        "context7",
+        "get-library-docs",
+        "--libraryId", libraryId,
+        "--topic", topic,
+        "--tokens", "5000",
+      ],
+      { timeout: 15_000 }
+    );
+
+    const snippet = docsResult.stdout?.trim();
+    if (!snippet) return CONTEXT7_UNAVAILABLE;
+
+    return { snippet, topic, source: "context7" };
+  } catch {
+    return CONTEXT7_UNAVAILABLE;
+  }
+}

package/tools/frappe-query-tools.ts

@@ -0,0 +1,47 @@
+import { execa } from "execa";
+import { loadConfig } from "../config/loader.js";
+import { routeThroughContextMode } from "./context-sandbox.js";
+
+export interface FrappeQueryArgs {
+  doctype: string;
+  filters?: Record<string, unknown>;
+}
+
+export interface FrappeQueryResult {
+  summary?: string;
+  error?: string;
+}
+
+/**
+ * Dispatches a Frappe get_list query via mcp2cli subprocess.
+ * Raw output is routed through context-mode sandbox — never returned directly.
+ * Returns structured error on failure, never throws.
+ *
+ * Note: mcp2cli command syntax uses --mcp <url> --raw <tool_name> <json_args>.
+ * Adapt args array if actual mcp2cli CLI syntax differs.
+ */
+export async function frappeQuery({ doctype, filters }: FrappeQueryArgs): Promise<FrappeQueryResult> {
+  const config = loadConfig();
+
+  if (!config.frappeMcpUrl) {
+    return { error: "frappeMcpUrl not configured in ~/.frappe-builder/config.json" };
+  }
+
+  try {
+    const payload = JSON.stringify({ doctype, filters: filters ?? {} });
+    const { stdout, stderr } = await execa("mcp2cli", [
+      "--mcp", config.frappeMcpUrl,
+      "--raw",
+      "frappe_get_list",
+      payload,
+    ]);
+
+    if (stderr) console.warn(`[frappe_query mcp2cli stderr: ${stderr}]`);
+
+    const summary = await routeThroughContextMode(stdout);
+    return { summary };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { error: msg };
+  }
+}

package/tools/project-tools.ts

@@ -0,0 +1,107 @@
+import { db, switchProject } from "../state/db.js";
+import { reloadSessionContext } from "../extensions/frappe-session.js";
+
+export interface ComponentStatus {
+  componentId: string;
+  status: string;
+  completedAt: string | null;
+}
+
+export interface FeatureStatus {
+  featureId: string;
+  name: string;
+  phase: string;
+  componentsDone: number;
+  componentsTotal: number;
+  components: ComponentStatus[];
+  lastUpdated: string | null;
+}
+
+export interface ProjectStatus {
+  features: FeatureStatus[];
+  message?: string;
+}
+
+/**
+ * Returns a dashboard summary of all features, components, and phases from state.db.
+ * Reads exclusively from state.db — no live Frappe queries.
+ * Returns graceful empty state when no features have been started.
+ */
+export function getProjectStatus(_args?: unknown): ProjectStatus {
+  const rows = db
+    .prepare(
+      "SELECT feature_id, name, current_phase, progress_done, progress_total, updated_at FROM features ORDER BY created_at ASC"
+    )
+    .all() as {
+      feature_id: string;
+      name: string;
+      current_phase: string;
+      progress_done: number;
+      progress_total: number;
+      updated_at: string | null;
+    }[];
+
+  if (rows.length === 0) {
+    return { features: [], message: "No features started yet" };
+  }
+
+  const features: FeatureStatus[] = rows.map((f) => {
+    const rawComponents = db
+      .prepare(
+        "SELECT component_id, status, completed_at FROM components WHERE feature_id = ? ORDER BY component_id ASC"
+      )
+      .all(f.feature_id) as { component_id: string; status: string; completed_at: string | null }[];
+
+    const components: ComponentStatus[] = rawComponents.map((c) => ({
+      componentId: c.component_id,
+      status: c.status,
+      completedAt: c.completed_at,
+    }));
+
+    const done = components.filter((c) => c.status === "complete").length;
+
+    return {
+      featureId: f.feature_id,
+      name: f.name,
+      phase: f.current_phase,
+      componentsDone: done,
+      componentsTotal: components.length,
+      components,
+      lastUpdated: f.updated_at,
+    };
+  });
+
+  return { features };
+}
+
+interface SetActiveProjectArgs {
+  projectId: string;
+  sitePath: string;
+}
+
+/**
+ * Switches the active Frappe project and site, flushes current session state,
+ * creates a new session, and reloads the system prompt context.
+ *
+ * The state_transition JSONL entry is written inside switchProject() —
+ * no second appendEntry() call here.
+ */
+export async function setActiveProject({ projectId, sitePath }: SetActiveProjectArgs) {
+  // Flush current state + create new session (JSONL entry written internally)
+  switchProject(projectId, sitePath);
+
+  // Reload system prompt with new project context
+  await reloadSessionContext();
+
+  // Read restored phase for return value
+  const session = db
+    .prepare("SELECT current_phase FROM sessions WHERE is_active = 1 LIMIT 1")
+    .get() as { current_phase: string } | undefined;
+
+  return {
+    project_id: projectId,
+    site_path: sitePath,
+    phase: session?.current_phase ?? "idle",
+    context_reloaded: true,
+  };
+}

package/tsdown.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/cli.ts"],
+  format: "esm",
+  banner: { js: "#!/usr/bin/env node" },
+});