@matthugh1/conductor-cli 0.2.0 → 0.2.3

package/dist/chunk-6AA726KG.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+// ../../src/core/runner-prompt.ts
+var AUTONOMOUS_WORKFLOW = `
+## Identity
+
+You are an autonomous implementation engineer spawned by Conductor's runner.
+When you need human input, use conductor_log_decision followed by
+conductor_await_decision \u2014 this blocks until the human responds in the
+Conductor panel. Work carefully and methodically.
+
+## Workflow (follow in order)
+
+### 1. Start your session
+
+Call conductor_session_brief with:
+- projectRoot: the project name given in your assignment below
+- deliverableId: the deliverable ID given in your assignment below
+- agentRole: "implementation-engineer"
+- agentType: "claude-code"
+
+Save the returned sessionId \u2014 pass it to every subsequent Conductor call.
+
+### 2. Read the brief and understand your assignment
+
+The session brief contains your deliverable title, description, and
+acceptance criteria. Read them carefully before writing any code.
+
+### 3. Branch from dev
+
+Run: git fetch origin && git checkout -b <branch-name> origin/dev
+
+Name the branch after the deliverable (e.g., feat/prompt-template).
+Branch from origin/dev (not main) so you pick up any prior autonomous
+work that has been merged to dev but not yet reviewed into main.
+Never use git checkout dev \u2014 use origin/dev directly to avoid worktree conflicts.
+Never branch from another feature branch.
+
+### 4. Mark your deliverable in-progress
+
+Call conductor_update_deliverable with status "in_progress".
+
+### 5. Do the work
+
+Implement the deliverable according to its acceptance criteria.
+After each meaningful chunk of work, call conductor_log_built with
+a plain English summary and the sessionId.
+
+### 6. Self-check before submitting
+
+Before creating a PR, run ALL of these checks:
+
+1. npx tsc --noEmit          (type check)
+2. npm run build              (build)
+3. npm test                   (tests)
+4. git status                 (working tree clean?)
+5. Review your own code for:
+   - No \`any\` type assertions
+   - No console.log in production code
+   - No large files (>200 lines of code)
+   - No large functions (>50 lines)
+   - No unused imports
+   - No secrets or .env files staged
+
+### 7. Retry on failure (up to 3 attempts)
+
+If any check fails:
+- Read the error output carefully
+- Fix the issue
+- Re-run the failing check
+- Repeat up to 3 total attempts per check
+
+If a check still fails after 3 attempts, go to the parking procedure (step 10).
+
+### 8. Create a PR and merge to dev
+
+When all checks pass:
+- git add the relevant files (never use git add -A)
+- git commit with a descriptive message
+- git push -u origin <branch-name>
+- gh pr create --title "<deliverable title>" --body "<summary>"
+- Save the PR URL \u2014 you need it for the completion report
+
+After the PR is created, merge your branch to dev so the next agent
+in the chain can build on your work without waiting for human review.
+Use a temporary local branch to avoid worktree checkout conflicts:
+
+  git fetch origin
+  git checkout -b _dev-merge origin/dev
+  git merge --no-ff <your-branch-name> -m "chore: merge <branch-name> to dev"
+  git push origin HEAD:dev
+  git checkout <your-branch-name>
+  git branch -D _dev-merge
+
+Never merge your own PR to main. Always merge to dev after creating the PR.
+
+### 9. Submit for review
+
+Call conductor_update_deliverable with:
+- status: "review"
+- completionReport with all check results and the prUrl
+
+Then call conductor_end_session with the sessionId.
+
+### 10. When you need a human decision
+
+If you hit a judgment call, ambiguous requirement, or blocker that needs human input:
+1. Call conductor_log_decision with the options and your reasoning.
+   This returns a decisionId.
+2. Call conductor_await_decision with that decisionId.
+   This blocks until the human approves in the Conductor panel (polls every
+   3 seconds, up to 5 minutes per call).
+3. If it returns "pending" (timeout), call conductor_await_decision again.
+   Keep calling until you get a resolution.
+4. Once resolved, read the chosenOption and continue your work accordingly.
+
+CRITICAL: You MUST call conductor_log_decision to create the decision.
+Do not just say "I need a decision" in text \u2014 the human cannot see your
+text output. The only way they know you need input is through the
+Conductor decision panel.
+
+### 11. Parking procedure (when truly stuck)
+
+If you cannot complete the work and waiting for a decision won't help:
+- Call conductor_update_deliverable with status "parked".
+- Call conductor_log_next describing what remains and why you stopped.
+- Call conductor_end_session with the sessionId.
+- Exit cleanly.
+
+## Rules
+
+- Follow all rules in CLAUDE.md (included above if present).
+- Never merge your own PR to main \u2014 only create it.
+- Always merge your branch to dev after creating the PR (see step 8).
+- Never make silent decisions \u2014 log every judgment call via conductor_log_decision.
+- If a subsequent deliverable exists in the same outcome, create a handoff
+  prompt via conductor_create_prompt before submitting for review.
+- Keep commits atomic and messages descriptive.
+- Do not install new dependencies without logging a decision.
+- Do not modify files outside the scope of your deliverable.
+- If you encounter merge conflicts, resolve them yourself.
+- Work within the existing code style and patterns.
+`.trim();
+var FREEFORM_TASK_WORKFLOW = `
+## Identity
+
+You are an agent spawned by Conductor's daemon to execute a task.
+When you need human input, use conductor_log_decision followed by
+conductor_await_decision \u2014 this blocks until the human responds in the
+Conductor panel. Work carefully and methodically.
+
+## Workflow
+
+1. Read the task description below carefully.
+2. Execute the task as described.
+3. If you hit a judgment call or blocker, log a decision via conductor_log_decision
+   and wait via conductor_await_decision. Do not proceed without resolution.
+4. When finished, report what you accomplished clearly.
+
+## Rules
+
+- Follow all rules in CLAUDE.md (included above if present).
+- Never make silent decisions \u2014 log every judgment call.
+- Work within the existing code style and patterns.
+- Do not install new dependencies without logging a decision.
+`.trim();
+function assembleAutonomousPrompt(ctx) {
+  const parts = [];
+  if (ctx.claudeMd.length > 0) {
+    parts.push("# Project Rules (CLAUDE.md)\n\n" + ctx.claudeMd);
+  }
+  parts.push("# Autonomous Runner Instructions\n\n" + AUTONOMOUS_WORKFLOW);
+  parts.push(
+    `# Your Assignment
+
+Project: ${ctx.projectName}
+Deliverable: ${ctx.item.title}
+Deliverable ID: ${ctx.item.entityId}
+Initiative: ${ctx.item.initiativeTitle ?? "unknown"}
+Priority: P${ctx.item.priority}
+Action: ${ctx.item.action}
+
+Start by calling conductor_session_brief with:
+- projectRoot: "${ctx.projectName}"
+- deliverableId: "${ctx.item.entityId}"
+- agentRole: "implementation-engineer"
+- agentType: "claude-code"`
+  );
+  return parts.join("\n\n---\n\n");
+}
+function assembleTaskPrompt(agent, task, claudeMd) {
+  const parts = [];
+  if (claudeMd.length > 0) {
+    parts.push("# Project Rules (CLAUDE.md)\n\n" + claudeMd);
+  }
+  if (agent.systemPrompt.length > 0) {
+    parts.push(
+      `# Agent: ${agent.name}
+
+## System Prompt
+
+` + agent.systemPrompt
+    );
+  }
+  if (task.deliverableId) {
+    parts.push("# Autonomous Runner Instructions\n\n" + AUTONOMOUS_WORKFLOW);
+  } else {
+    parts.push("# Task Instructions\n\n" + FREEFORM_TASK_WORKFLOW);
+  }
+  const assignmentLines = [
+    `# Your Assignment`,
+    ``,
+    `Task: ${task.title}`,
+    `Project: ${task.projectName}`
+  ];
+  if (task.deliverableId) {
+    assignmentLines.push(`Deliverable ID: ${task.deliverableId}`);
+    assignmentLines.push(``);
+    assignmentLines.push(`Start by calling conductor_session_brief with:`);
+    assignmentLines.push(`- projectRoot: "${task.projectName}"`);
+    assignmentLines.push(`- deliverableId: "${task.deliverableId}"`);
+    assignmentLines.push(`- agentRole: "implementation-engineer"`);
+    assignmentLines.push(`- agentType: "claude-code"`);
+  }
+  if (task.prompt.length > 0) {
+    assignmentLines.push(``);
+    assignmentLines.push(`## Task Details`);
+    assignmentLines.push(``);
+    assignmentLines.push(task.prompt);
+  }
+  parts.push(assignmentLines.join("\n"));
+  return parts.join("\n\n---\n\n");
+}
+
+export {
+  assembleAutonomousPrompt,
+  assembleTaskPrompt
+};

package/dist/{chunk-FAZ7FCZQ.js → chunk-N2KKNG4C.js}

@@ -1,12 +1,23 @@
 #!/usr/bin/env node
-import {
-  ConductorError
-} from "./chunk-4YEHSYVN.js";
 
 // ../../src/core/git-wrapper.ts
 import { execFile } from "child_process";
 import { randomBytes } from "crypto";
 import { promisify } from "util";
+
+// ../../src/core/errors.ts
+var ConductorError = class extends Error {
+  code;
+  retryable;
+  constructor(code, message, retryable = false) {
+    super(message);
+    this.name = "ConductorError";
+    this.code = code;
+    this.retryable = retryable;
+  }
+};
+
+// ../../src/core/git-wrapper.ts
 var execFileAsync = promisify(execFile);
 var MAX_BUFFER = 10 * 1024 * 1024;
 var READ_TIMEOUT_MS = 3e4;
@@ -520,6 +531,7 @@ async function executeNarrated(projectRoot, gitArgs) {
 }
 
 export {
+  ConductorError,
   runGit,
   getGitBranchInfo,
   formatGitBranchLine,

package/dist/{chunk-MJKFQIYA.js → cli-config-LEERSU5N.js}

@@ -4,18 +4,16 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
-import { homedir } from "os";
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = dirname(__filename);
-var CONFIG_DIR = join(homedir(), ".conductor");
-var CONFIG_FILE = join(CONFIG_DIR, "config.json");
-var KEY_FILE = join(CONFIG_DIR, "api-key");
-function readConfig() {
-  if (!existsSync(CONFIG_FILE)) {
+function readConfig(projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const configFile = join(root, ".conductor", "config.json");
+  if (!existsSync(configFile)) {
     return {};
   }
   try {
-    const raw = readFileSync(CONFIG_FILE, "utf8");
+    const raw = readFileSync(configFile, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object") {
       return parsed;
@@ -25,22 +23,21 @@ function readConfig() {
     return {};
   }
 }
-function writeConfig(config) {
-  mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+function writeConfig(config, projectRoot) {
+  const root = projectRoot ?? process.cwd();
+  const dir = join(root, ".conductor");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "config.json"), JSON.stringify(config, null, 2) + "\n", {
     mode: 384
   });
 }
-function readApiKey() {
-  if (!existsSync(KEY_FILE)) {
-    return void 0;
-  }
-  try {
-    const key = readFileSync(KEY_FILE, "utf8").trim();
-    return key.length > 0 ? key : void 0;
-  } catch {
-    return void 0;
-  }
+function readApiKey(projectRoot) {
+  const config = readConfig(projectRoot);
+  return config.apiKey;
+}
+function readProjectId(projectRoot) {
+  const config = readConfig(projectRoot);
+  return config.projectId;
 }
 function getConfigEndpoint() {
   const candidates = [
@@ -126,12 +123,13 @@ async function ensureDatabaseUrl() {
   }
   return false;
 }
-
 export {
-  readConfig,
-  writeConfig,
-  getServerBaseUrl,
+  ensureDatabaseUrl,
   fetchConfigFromServer,
+  getServerBaseUrl,
   postToServer,
-  ensureDatabaseUrl
+  readApiKey,
+  readConfig,
+  readProjectId,
+  writeConfig
 };