@benzotti/jedi 0.1.0 → 0.1.3

package/dist/index.js

@@ -7676,6 +7676,69 @@ var require_public_api = __commonJS((exports) => {
   exports.stringify = stringify;
 });
 
+// src/utils/git.ts
+var exports_git = {};
+__export(exports_git, {
+  gitStatus: () => gitStatus,
+  gitRoot: () => gitRoot,
+  gitMergeBase: () => gitMergeBase,
+  gitLog: () => gitLog,
+  gitDiffNames: () => gitDiffNames,
+  gitDiff: () => gitDiff,
+  gitBranch: () => gitBranch,
+  exec: () => exec
+});
+async function exec(cmd, cwd) {
+  const proc = Bun.spawn(cmd, {
+    cwd: cwd ?? process.cwd(),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const stdout2 = await new Response(proc.stdout).text();
+  const exitCode = await proc.exited;
+  return { stdout: stdout2.trim(), exitCode };
+}
+async function gitDiff(staged) {
+  const args = ["git", "diff"];
+  if (staged)
+    args.push("--cached");
+  const { stdout: stdout2 } = await exec(args);
+  return stdout2;
+}
+async function gitDiffNames(staged) {
+  const args = ["git", "diff", "--name-only"];
+  if (staged)
+    args.push("--cached");
+  const { stdout: stdout2 } = await exec(args);
+  return stdout2 ? stdout2.split(`
+`) : [];
+}
+async function gitLog(range) {
+  const args = ["git", "log", "--oneline"];
+  if (range)
+    args.push(range);
+  else
+    args.push("-20");
+  const { stdout: stdout2 } = await exec(args);
+  return stdout2;
+}
+async function gitBranch() {
+  const { stdout: stdout2 } = await exec(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
+  return stdout2;
+}
+async function gitRoot() {
+  const { stdout: stdout2 } = await exec(["git", "rev-parse", "--show-toplevel"]);
+  return stdout2;
+}
+async function gitStatus() {
+  const { stdout: stdout2 } = await exec(["git", "status", "--porcelain"]);
+  return stdout2;
+}
+async function gitMergeBase(branch) {
+  const { stdout: stdout2 } = await exec(["git", "merge-base", "HEAD", branch]);
+  return stdout2;
+}
+
 // node_modules/consola/dist/core.mjs
 var LogLevels = {
   silent: Number.NEGATIVE_INFINITY,
@@ -9292,11 +9355,135 @@ async function readAdapter(cwd) {
   return $parse(content);
 }
 
+// src/utils/claude.ts
+var PROMPT_LENGTH_THRESHOLD = 1e5;
+async function findClaude() {
+  const path = Bun.which("claude");
+  if (path)
+    return path;
+  const { exec: exec2 } = await Promise.resolve().then(() => exports_git);
+  const { stdout: stdout2, exitCode } = await exec2(["which", "claude"]);
+  if (exitCode === 0 && stdout2)
+    return stdout2;
+  throw new Error("Claude CLI not found. Install it from https://docs.anthropic.com/en/docs/claude-code");
+}
+var lastEventType = "";
+function formatStreamEvent(event) {
+  if (event.type === "assistant" && event.message?.content) {
+    const parts = [];
+    for (const block of event.message.content) {
+      if (block.type === "text" && block.text) {
+        const prefix = lastEventType === "tool" ? `
+` : "";
+        parts.push(prefix + block.text.trim());
+        lastEventType = "text";
+      } else if (block.type === "tool_use") {
+        const name = block.name ?? "tool";
+        const input = block.input;
+        let detail = "";
+        if (input?.file_path) {
+          const segments = input.file_path.split("/");
+          detail = ` \u2192 ${segments.slice(-3).join("/")}`;
+        } else if (name === "Bash" && input?.command) {
+          detail = ` \u2192 ${input.command.slice(0, 60)}`;
+        } else if (input?.pattern) {
+          detail = ` \u2192 ${input.pattern}`;
+        }
+        parts.push(`  \u26A1 ${name}${detail}`);
+        lastEventType = "tool";
+      }
+    }
+    if (parts.length > 0)
+      return parts.join(`
+`) + `
+`;
+  }
+  if (event.type === "result" && event.subtype === "error_tool_result") {
+    lastEventType = "error";
+    return `  \u274C Tool error
+`;
+  }
+  return null;
+}
+async function spawnClaude(prompt2, opts) {
+  const claudePath = await findClaude();
+  const args = [
+    claudePath,
+    "-p",
+    "--verbose",
+    "--output-format",
+    "stream-json",
+    "--permission-mode",
+    opts?.permissionMode ?? "acceptEdits"
+  ];
+  if (opts?.allowedTools) {
+    for (const tool of opts.allowedTools) {
+      args.push("--allowedTools", tool);
+    }
+  }
+  if (opts?.model) {
+    args.push("--model", opts.model);
+  }
+  const useStdin = prompt2.length >= PROMPT_LENGTH_THRESHOLD;
+  if (!useStdin) {
+    args.push(prompt2);
+  }
+  consola.start(`Launching Claude Code...
+`);
+  const proc = Bun.spawn(args, {
+    cwd: opts?.cwd ?? process.cwd(),
+    stdout: "pipe",
+    stderr: "inherit",
+    stdin: useStdin ? "pipe" : "ignore"
+  });
+  if (useStdin) {
+    proc.stdin.write(prompt2);
+    proc.stdin.end();
+  }
+  const reader = proc.stdout.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+          continue;
+        try {
+          const event = JSON.parse(trimmed);
+          const output = formatStreamEvent(event);
+          if (output)
+            process.stdout.write(output);
+        } catch {}
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        const event = JSON.parse(buffer.trim());
+        const output = formatStreamEvent(event);
+        if (output)
+          process.stdout.write(output);
+      } catch {}
+    }
+  } catch {}
+  const exitCode = await proc.exited;
+  process.stdout.write(`
+`);
+  return { exitCode };
+}
+
 // src/commands/plan.ts
 var planCommand = defineCommand({
   meta: {
     name: "plan",
-    description: "Generate a planning prompt for Claude Code"
+    description: "Plan a feature using Claude Code"
   },
   args: {
     description: {
@@ -9307,6 +9494,11 @@ var planCommand = defineCommand({
     output: {
       type: "string",
       description: "Write prompt to file instead of stdout"
+    },
+    print: {
+      type: "boolean",
+      description: "Print the prompt to stdout instead of executing",
+      default: false
     }
   },
   async run({ args }) {
@@ -9336,29 +9528,57 @@ var planCommand = defineCommand({
     if (args.output) {
       await Bun.write(resolve2(cwd, args.output), prompt2);
       consola.success(`Prompt written to ${args.output}`);
-    } else {
+    } else if (args.print) {
       console.log(prompt2);
+    } else {
+      const { exitCode } = await spawnClaude(prompt2, { cwd });
+      if (exitCode !== 0) {
+        consola.error(`Claude exited with code ${exitCode}`);
+        process.exit(exitCode);
+      }
     }
   }
 });
 
 // src/commands/implement.ts
 import { resolve as resolve3 } from "path";
+
+// src/utils/state.ts
+import { join as join5 } from "path";
+import { existsSync as existsSync4 } from "fs";
+async function readState(cwd) {
+  const statePath = join5(cwd, ".jdi", "config", "state.yaml");
+  if (!existsSync4(statePath))
+    return null;
+  const content = await Bun.file(statePath).text();
+  return $parse(content);
+}
+async function writeState(cwd, state) {
+  const statePath = join5(cwd, ".jdi", "config", "state.yaml");
+  await Bun.write(statePath, $stringify(state));
+}
+
+// src/commands/implement.ts
 var implementCommand = defineCommand({
   meta: {
     name: "implement",
-    description: "Generate an implementation prompt for Claude Code"
+    description: "Execute an implementation plan using Claude Code"
   },
   args: {
     plan: {
       type: "positional",
-      description: "Path to the PLAN.md file to execute",
-      required: true
+      description: "Path to the PLAN.md file (auto-detected from state if omitted)",
+      required: false
     },
     output: {
       type: "string",
       description: "Write prompt to file instead of stdout"
     },
+    print: {
+      type: "boolean",
+      description: "Print the prompt to stdout instead of executing",
+      default: false
+    },
     team: {
       type: "boolean",
       description: "Force Agent Teams mode",
@@ -9372,6 +9592,16 @@ var implementCommand = defineCommand({
   },
   async run({ args }) {
     const cwd = process.cwd();
+    let planPath = args.plan;
+    if (!planPath) {
+      const state = await readState(cwd);
+      planPath = state?.current_plan?.path ?? null;
+      if (!planPath) {
+        consola.error("No plan specified and no current plan found in state. Run `jdi plan` first or provide a plan path.");
+        process.exit(1);
+      }
+      consola.info(`Using current plan: ${planPath}`);
+    }
     const baseProtocol = resolve3(cwd, ".jdi/framework/components/meta/AgentBase.md");
     const complexityRouter = resolve3(cwd, ".jdi/framework/components/meta/ComplexityRouter.md");
     const orchestration = resolve3(cwd, ".jdi/framework/components/meta/AgentTeamsOrchestration.md");
@@ -9394,7 +9624,7 @@ Override: --single (force single-agent mode)` : "";
       `- Working directory: ${cwd}`,
       ``,
       `## Task`,
-      `Execute implementation plan: ${resolve3(cwd, args.plan)}${overrideFlag}`,
+      `Execute implementation plan: ${resolve3(cwd, planPath)}${overrideFlag}`,
       ``,
       `Follow the implement-plan orchestration:`,
       `1. Read codebase context (.jdi/codebase/SUMMARY.md if exists)`,
@@ -9410,27 +9640,18 @@ Override: --single (force single-agent mode)` : "";
     if (args.output) {
       await Bun.write(resolve3(cwd, args.output), prompt2);
       consola.success(`Prompt written to ${args.output}`);
-    } else {
+    } else if (args.print) {
       console.log(prompt2);
+    } else {
+      const { exitCode } = await spawnClaude(prompt2, { cwd });
+      if (exitCode !== 0) {
+        consola.error(`Claude exited with code ${exitCode}`);
+        process.exit(exitCode);
+      }
     }
   }
 });
 
-// src/utils/state.ts
-import { join as join5 } from "path";
-import { existsSync as existsSync4 } from "fs";
-async function readState(cwd) {
-  const statePath = join5(cwd, ".jdi", "config", "state.yaml");
-  if (!existsSync4(statePath))
-    return null;
-  const content = await Bun.file(statePath).text();
-  return $parse(content);
-}
-async function writeState(cwd, state) {
-  const statePath = join5(cwd, ".jdi", "config", "state.yaml");
-  await Bun.write(statePath, $stringify(state));
-}
-
 // src/commands/status.ts
 var statusCommand = defineCommand({
   meta: {
@@ -9523,51 +9744,6 @@ var componentsCommand = defineCommand({
   }
 });
 
-// src/utils/git.ts
-async function exec(cmd, cwd) {
-  const proc = Bun.spawn(cmd, {
-    cwd: cwd ?? process.cwd(),
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const stdout2 = await new Response(proc.stdout).text();
-  const exitCode = await proc.exited;
-  return { stdout: stdout2.trim(), exitCode };
-}
-async function gitDiffNames(staged) {
-  const args = ["git", "diff", "--name-only"];
-  if (staged)
-    args.push("--cached");
-  const { stdout: stdout2 } = await exec(args);
-  return stdout2 ? stdout2.split(`
-`) : [];
-}
-async function gitLog(range) {
-  const args = ["git", "log", "--oneline"];
-  if (range)
-    args.push(range);
-  else
-    args.push("-20");
-  const { stdout: stdout2 } = await exec(args);
-  return stdout2;
-}
-async function gitBranch() {
-  const { stdout: stdout2 } = await exec(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
-  return stdout2;
-}
-async function gitRoot() {
-  const { stdout: stdout2 } = await exec(["git", "rev-parse", "--show-toplevel"]);
-  return stdout2;
-}
-async function gitStatus() {
-  const { stdout: stdout2 } = await exec(["git", "status", "--porcelain"]);
-  return stdout2;
-}
-async function gitMergeBase(branch) {
-  const { stdout: stdout2 } = await exec(["git", "merge-base", "HEAD", branch]);
-  return stdout2;
-}
-
 // src/commands/commit.ts
 import { dirname as dirname2 } from "path";
 function detectScope(files) {
@@ -9791,7 +9967,7 @@ import { resolve as resolve5 } from "path";
 var reviewCommand = defineCommand({
   meta: {
     name: "review",
-    description: "Fetch PR diff and generate a structured review prompt"
+    description: "Review a PR using Claude Code"
   },
   args: {
     pr: {
@@ -9802,6 +9978,11 @@ var reviewCommand = defineCommand({
     output: {
       type: "string",
       description: "Write prompt to file instead of stdout"
+    },
+    print: {
+      type: "boolean",
+      description: "Print the prompt to stdout instead of executing",
+      default: false
     }
   },
   async run({ args }) {
@@ -9878,8 +10059,14 @@ ${data.body}` : ""
     if (args.output) {
       await Bun.write(resolve5(process.cwd(), args.output), prompt2);
       consola.success(`Review prompt written to ${args.output}`);
-    } else {
+    } else if (args.print) {
       console.log(prompt2);
+    } else {
+      const { exitCode } = await spawnClaude(prompt2, { cwd: process.cwd() });
+      if (exitCode !== 0) {
+        consola.error(`Claude exited with code ${exitCode}`);
+        process.exit(exitCode);
+      }
     }
   }
 });
@@ -10013,7 +10200,7 @@ import { resolve as resolve6 } from "path";
 var quickCommand = defineCommand({
   meta: {
     name: "quick",
-    description: "Generate a focused change prompt for Claude Code"
+    description: "Make a focused change using Claude Code"
   },
   args: {
     description: {
@@ -10024,6 +10211,11 @@ var quickCommand = defineCommand({
     output: {
       type: "string",
       description: "Write prompt to file instead of stdout"
+    },
+    print: {
+      type: "boolean",
+      description: "Print the prompt to stdout instead of executing",
+      default: false
     }
   },
   async run({ args }) {
@@ -10057,8 +10249,14 @@ var quickCommand = defineCommand({
     if (args.output) {
       await Bun.write(resolve6(cwd, args.output), prompt2);
       consola.success(`Prompt written to ${args.output}`);
-    } else {
+    } else if (args.print) {
       console.log(prompt2);
+    } else {
+      const { exitCode } = await spawnClaude(prompt2, { cwd });
+      if (exitCode !== 0) {
+        consola.error(`Claude exited with code ${exitCode}`);
+        process.exit(exitCode);
+      }
     }
   }
 });
@@ -10171,7 +10369,6 @@ var worktreeCommand = defineCommand({
     consola.info(`  cd ${worktreePath}`);
   }
 });
-
 // src/commands/worktree-remove.ts
 var worktreeRemoveCommand = defineCommand({
   meta: {
@@ -10449,8 +10646,8 @@ var planApproveCommand = defineCommand({
 });
 // package.json
 var package_default = {
-  name: "@zottiben/jdi",
-  version: "0.1.0",
+  name: "@benzotti/jedi",
+  version: "0.1.3",
   description: "JDI - Context-efficient AI development framework for Claude Code",
   type: "module",
   bin: {
@@ -10478,9 +10675,6 @@ var package_default = {
     type: "git",
     url: "https://github.com/zottiben/jedi.git"
   },
-  publishConfig: {
-    registry: "https://npm.pkg.github.com"
-  },
   license: "MIT",
   engines: {
     node: ">=18"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benzotti/jedi",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "JDI - Context-efficient AI development framework for Claude Code",
   "type": "module",
   "bin": {