chorus-cli 0.4.4 → 0.4.6

package/index.js

@@ -18,41 +18,49 @@ const execPromise = util.promisify(exec);
 const execFilePromise = util.promisify(execFile);
 const fs = require('fs').promises;
 
-// Returns a stable hardware UUID for this machine, with a persistent fallback
+// Returns a SHA-256 hash of this machine's hardware UUID (or a persistent random fallback).
+// The raw UUID never leaves the device — only the hash is sent to the server.
 async function getMachineId() {
+  const { createHash, randomUUID } = require('crypto');
+  let rawId;
+
   try {
     if (process.platform === 'darwin') {
       const { stdout } = await execPromise(
         "ioreg -rd1 -c IOPlatformExpertDevice | awk -F'\"' '/IOPlatformUUID/{print $4}'"
       );
-      if (stdout.trim()) return stdout.trim();
+      if (stdout.trim()) rawId = stdout.trim();
     } else if (process.platform === 'linux') {
-      const fsp = require('fs').promises;
-      const id = (await fsp.readFile('/etc/machine-id', 'utf8')).trim();
-      if (id) return id;
+      const id = (await fs.readFile('/etc/machine-id', 'utf8')).trim();
+      if (id) rawId = id;
     } else if (process.platform === 'win32') {
       const { stdout } = await execPromise('wmic csproduct get UUID');
       const lines = stdout.trim().split('\n');
       if (lines.length > 1) {
         const uuid = lines[1].trim();
-        if (uuid && uuid !== 'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF') return uuid;
+        if (uuid && uuid !== 'FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF') rawId = uuid;
       }
     }
   } catch { /* fall through to persistent fallback */ }
 
-  // Persistent fallback: generate and cache a random UUID
-  const configDir = path.join(os.homedir(), '.config', 'chorus');
-  const idPath = path.join(configDir, 'machine-id');
-  try {
-    const existing = await fs.readFile(idPath, 'utf8');
-    if (existing.trim()) return existing.trim();
-  } catch { /* no file yet */ }
+  if (!rawId) {
+    // Persistent fallback: generate and cache a random UUID
+    const configDir = path.join(os.homedir(), '.config', 'chorus');
+    const idPath = path.join(configDir, 'machine-id');
+    try {
+      const existing = await fs.readFile(idPath, 'utf8');
+      if (existing.trim()) rawId = existing.trim();
+    } catch { /* no file yet */ }
+
+    if (!rawId) {
+      rawId = randomUUID();
+      const configDir2 = path.join(os.homedir(), '.config', 'chorus');
+      await fs.mkdir(configDir2, { recursive: true });
+      await fs.writeFile(path.join(configDir2, 'machine-id'), rawId + '\n');
+    }
+  }
 
-  const { randomUUID } = require('crypto');
-  const newId = randomUUID();
-  await fs.mkdir(configDir, { recursive: true });
-  await fs.writeFile(idPath, newId + '\n');
-  return newId;
+  return createHash('sha256').update(rawId).digest('hex');
 }
 
 // Run coder.py with real-time stderr streaming so progress is visible

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chorus-cli",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "Automated ticket resolution with AI, Teams, and Slack integration",
   "main": "index.js",
   "bin": {

package/tools/coder.py

@@ -49,47 +49,183 @@ def is_token_limit_error(err):
     msg = str(err)
     return "token limit exceeded" in msg or "rate_limit_error" in msg
 
-SYSTEM_PROMPT = """\
-You are a coding agent running inside a CLI tool called Chorus.
-Your output goes straight to a terminal. There is no browser, no rich renderer.
+
+# ── Shared formatting rules (included in all prompts) ─────────────────────
+_FORMAT_RULES = """\
+OUTPUT FORMAT
+
+Your output is displayed raw in a terminal. Never use markdown.
+No headings with #, no **bold**, no *italic*, no `backticks`, no [links](url),
+no bullet characters like - or *.
+Use blank lines and indentation for structure. Use CAPS for section labels.
+Use plain numbered lists (1. 2. 3.) when listing things.
+Refer to code identifiers by name directly (e.g. myFunction not `myFunction`).
+No greetings, preambles, encouragement, or sign-offs.
+No "Great question!", "Let me", "Sure!", "I'll now", or similar filler.
+State what you are doing, then do it. After completing work, state what changed."""
+
+# ── Phase 1: Planning prompt (used once at the start of headless mode) ────
+PLAN_PROMPT = """\
+You are a coding agent. You receive a GitHub/Azure DevOps issue, a codebase map, \
+and optionally a QA conversation with clarified requirements. Your job is to \
+plan the implementation.
+
+Working directory: {cwd}
+
+""" + _FORMAT_RULES + """
+
+
+TASK
+
+Read the issue, QA conversation (if provided), and codebase map. Then produce a
+written plan with exactly these sections:
+
+UNDERSTANDING:
+What the issue is asking for in one sentence.
+
+QUESTIONS STILL OPEN:
+Anything unresolved from QA. If --skip-qa was used, list assumptions you are making
+and flag them clearly. Prefer the conservative/conventional choice for each.
+
+FILES TO READ:
+The minimum set of existing files you need to examine to understand the patterns,
+interfaces, and conventions. Maximum 8 files. Justify each.
+
+FILES TO CREATE:
+New files with their paths and a one-line description of contents.
+
+FILES TO MODIFY:
+Existing files with a one-line description of what changes.
+
+APPROACH:
+How you will implement this in 2-4 sentences. Reference specific patterns
+from the codebase map.
+
+ON AMBIGUITY
+
+When requirements are unclear and no QA conversation was provided:
+1. State your assumption explicitly.
+2. Choose the most conventional/standard approach.
+3. Flag it so the reviewer can catch disagreements early.
+Do not guess ambitiously. Guess conservatively. A correct simple implementation beats
+a broken ambitious one.
+"""
+
+# ── Phase 2: Execution prompt (used on every turn of the tool loop) ───────
+EXEC_PROMPT = """\
+You are a coding agent executing a plan. Implement the changes described in the
+plan below. Do not re-plan or re-analyze. Execute.
+
 Working directory: {cwd}
 
-You help with software engineering tasks: writing code, debugging, refactoring, \
-explaining code, running commands, and managing files.
-
-Formatting:
-- Plain text only. Never use markdown.
-- No ## headers, **bold**, *italic*, `backticks`, [links](url), or bullet symbols like -.
-- Use blank lines, indentation, and CAPS for emphasis or section labels.
-- Use plain numbered lists (1. 2. 3.) when listing things.
-- Refer to code identifiers by name directly (e.g. myFunction, not `myFunction`).
-
-Communication style:
-- Be terse. Say what you are doing and why in one or two lines, then do it.
-- No greetings, preambles, encouragement, or sign-offs.
-- No "Great question!", "Let me", "Sure!", "I'll now", or similar filler.
-- When explaining your plan, use short declarative sentences. Skip obvious reasoning.
-- After completing work, state what changed and nothing else.
-
-{approach}Guidelines:
-- Always use your tools. If a question can be answered by running a command (git, ls, etc.), use the bash tool. Never guess.
-- Always read a file before editing it.
-- If edit_file fails with "old_string not found", re-read the file to get the actual current content before retrying. Never guess at file contents.
-- Use edit_file for targeted changes. Use write_file for new files or complete rewrites.
-- Prefer editing existing files over creating new ones.
-- Do not write new unit tests unless the project already has substantive test coverage.
-- Do not attempt to build or compile the project.
-- Don't add unnecessary comments, docstrings, or type annotations.
-- For bash commands, prefer non-interactive commands.
-- When asked about the codebase, use list_files and search_files to explore it.
+""" + _FORMAT_RULES + """
+
+
+TOOL USAGE
+
+  Always use read_file before editing a file.
+  If edit_file fails with "old_string not found", re-read the file with read_file to
+  get the actual current content before retrying. Never guess at file contents.
+  Use edit_file for targeted changes. Use write_file for new files or complete rewrites.
+  Prefer editing existing files over creating new ones.
+  Use read_file, list_files, and search_files instead of bash with cat, find, or grep.
+
+EXECUTION RULES
+
+Reading files:
+  Only use read_file on files listed in the plan. If you discover you need another
+  file, note why -- but if you have read more than 12 files total, stop and
+  re-evaluate. You are exploring, not implementing.
+  The one exception to reading a file again: if edit_file fails because old_string
+  was not found, re-read that file to get its current content before retrying.
+
+Writing code:
+  Follow existing patterns exactly. Match the conventions you observed for: naming,
+  exports, file structure, import ordering, indentation, and comment style.
+  Write complete files. Do not leave TODOs, placeholders, or "implement this" comments.
+  If the issue asks for a tool/script, it must work non-interactively (accept arguments
+  or config, not interactive prompts) unless the issue explicitly requires interactivity.
+
+Shell commands (bash tool):
+  You may run bash for: installing dependencies, running the project's existing
+  linter, running the project's existing tests, checking TypeScript compilation.
+  You may not run bash for: exploratory searching beyond what was in the plan,
+  reading files you did not plan to read, testing scripts with improvised piped input.
+  Maximum 10 bash commands total. If you are approaching this limit, you are doing
+  too much exploration or too much debugging. Ship what you have.
+
+BUDGET DISCIPLINE
+
+  Front-load the high-value work. Write the actual implementation code early. File
+  exploration is not progress -- committed code is progress.
+
+  Do not retry the same failing approach. If something fails twice, choose a different
+  approach or simplify. Do not iterate more than twice on the same problem.
+
+  If something fundamental is broken, stop. Produce what you have, note what is
+  incomplete, and let the human finish. A partial, clean implementation is more
+  valuable than a complete, broken one.
+
+  No yak-shaving. Deliver the core ask. Do not create demo scripts, markdown docs,
+  bash wrappers, or sample outputs unless the issue asks for them.
+
+WHAT NOT TO DO
+
+  Do not explore the filesystem to "understand the project." The codebase map and your
+  plan already cover that. Read specific files for specific reasons.
+
+  Do not overuse list_files, search_files, or bash for exploration. If you need more
+  than 3 exploratory calls, your plan was insufficient.
+
+  Do not create interactive scripts that require stdin.
+  Do not create documentation or READMEs unless the issue asks for them.
+  Do not modify package.json, CI configs, or project infrastructure unless the issue
+  specifically requires it.
+  Do not keep going when stuck. After 2 failed attempts at the same problem, note the
+  issue, deliver what works, and move on.
+
+WHEN YOU ARE DONE
+
+End with a verify block:
+
+1. List every file you created or modified.
+2. For each, confirm it is syntactically valid (ran linter or compiler if available).
+3. If tests exist for the area you changed, run them and confirm they pass.
+4. If you wrote a script/CLI tool, show the --help output or a dry-run invocation.
+5. Write a summary in this exact format:
+
+PR_TITLE: conventional commit format (feat:, fix:, chore:, etc.)
+PR_BODY: what changed, why, any assumptions made, anything the reviewer should
+look at carefully.
+
+Do not output anything after the summary.
 """
 
-APPROACH_BLOCK = """\
-Approach:
-- Before making changes, read the relevant files and briefly state your approach.
-- For multi-file changes, outline which files you'll modify and in what order.
-- Do not start editing until you understand the existing code.
+# ── Interactive REPL prompt (conversational, no phased workflow) ──────────
+REPL_PROMPT = """\
+You are a coding agent running in an interactive terminal session.
+Working directory: {cwd}
+
+""" + _FORMAT_RULES + """
+
+
+TOOL USAGE
+
+  Always use read_file before editing a file.
+  If edit_file fails with "old_string not found", re-read the file with read_file to
+  get the actual current content before retrying. Never guess at file contents.
+  Use edit_file for targeted changes. Use write_file for new files or complete rewrites.
+  Prefer editing existing files over creating new ones.
+  Use read_file, list_files, and search_files instead of bash with cat, find, or grep.
 
+GUIDELINES
+
+  Be direct and concise. State what you will do, then do it.
+  Always use your tools. Never guess when you can look.
+  Do not write new unit tests unless the project already has substantive test coverage.
+  Do not attempt to build or compile the project unless asked.
+  Do not add unnecessary comments, docstrings, or type annotations.
+  For bash commands, prefer non-interactive commands.
 """
 
 # ── Tool Definitions ────────────────────────────────────────────────────────
@@ -689,18 +825,19 @@ def stream_response(client, messages, system):
 
 # ── Headless Prompt Mode ────────────────────────────────────────────────────
 
-def run_prompt(client, prompt, system):
+def run_prompt(client, prompt, plan_system, exec_system):
     """Run a single prompt non-interactively. Returns a JSON-serializable dict."""
-    
-    # PHASE 1: Planning - ask the model to explain its approach first
+
+    # PHASE 1: Planning - separate API call with planning prompt
     print(f"\n{C.BOLD}{C.BLUE}📝 PLANNING PHASE{C.RESET}", file=sys.stderr, flush=True)
     print(f"{C.DIM}Understanding the issue and creating a plan...{C.RESET}\n", file=sys.stderr, flush=True)
-    
+
+    plan_text = ""
     plan_messages = [
-        {"role": "system", "content": system},
-        {"role": "user", "content": f"{prompt}\n\nBefore making any code changes, briefly state:\n1. The goal\n2. Files to examine\n3. Files to modify and how\n\nKeep it short. Do NOT write any code yet."}
+        {"role": "system", "content": plan_system},
+        {"role": "user", "content": f"{prompt}\n\nProduce the plan using the exact sections: UNDERSTANDING, QUESTIONS STILL OPEN, FILES TO READ, FILES TO CREATE, FILES TO MODIFY, APPROACH. Do NOT write any code yet."}
     ]
-    
+
     try:
         plan_response = client.chat.completions.create(
             model=MODEL,
@@ -708,23 +845,26 @@ def run_prompt(client, prompt, system):
             messages=plan_messages,
         )
         plan_text = plan_response.choices[0].message.content.strip()
-        
+
         # Print the plan with formatting
         print(f"{C.CYAN}{'─' * 60}{C.RESET}", file=sys.stderr, flush=True)
         for line in plan_text.split('\n'):
             print(f"{C.CYAN}  {line}{C.RESET}", file=sys.stderr, flush=True)
         print(f"{C.CYAN}{'─' * 60}{C.RESET}\n", file=sys.stderr, flush=True)
-        
+
     except Exception as e:
         print(f"{C.YELLOW}Could not generate plan: {e}{C.RESET}", file=sys.stderr, flush=True)
-        plan_text = ""
-    
-    # PHASE 2: Execution - proceed with the actual coding
+
+    # PHASE 2: Execution - inject plan into the conversation so the agent can reference it
     print(f"{C.BOLD}{C.GREEN}🔨 EXECUTING PLAN{C.RESET}\n", file=sys.stderr, flush=True)
-    
+
+    exec_user_content = prompt
+    if plan_text:
+        exec_user_content = f"{prompt}\n\nHere is your plan. Follow it.\n\n{plan_text}"
+
     messages = [
-        {"role": "system", "content": system},
-        {"role": "user", "content": prompt}
+        {"role": "system", "content": exec_system},
+        {"role": "user", "content": exec_user_content}
     ]
     files_modified = set()
     files_created = set()
@@ -867,37 +1007,22 @@ def run_prompt(client, prompt, system):
             final_text = msg.content
             break
 
-    # Ask LLM for a CodeRabbit-oriented summary (skip if we hit token limit)
+    # Parse PR_TITLE / PR_BODY from the agent's verify output (if present)
     summary = final_text.strip()
-    if not any(is_token_limit_error(e) for e in errors):
-        summary_messages = [
-            {"role": "system", "content": "You are a helpful assistant that summarizes code changes."},
-            {"role": "user", "content": (
-                f"Summarize these code changes in 2-3 sentences for a code review tool.\n\n"
-                f"Files modified: {', '.join(sorted(files_modified)) or 'none'}\n"
-                f"Files created: {', '.join(sorted(files_created)) or 'none'}\n\n"
-                f"Agent's final notes:\n{final_text[:2000]}\n\n"
-                f"Focus on what changed, what was added/fixed, and why. Be specific. No preamble."
-            )},
-        ]
-
-        try:
-            summary_response = client.chat.completions.create(
-                model=MODEL,
-                max_tokens=1024,
-                messages=summary_messages,
-            )
-
-            if hasattr(summary_response, "usage") and summary_response.usage:
-                total_input_tokens += summary_response.usage.prompt_tokens
-                total_output_tokens += summary_response.usage.completion_tokens
-
-            summary = summary_response.choices[0].message.content.strip()
-        except Exception as e:
-            if is_token_limit_error(e):
-                errors.append(str(e))
-            else:
-                raise
+    pr_title_match = re.search(r'PR_TITLE:\s*(.+)', final_text)
+    pr_body_match = re.search(r'PR_BODY:\s*([\s\S]+?)$', final_text)
+    if pr_title_match:
+        pr_title = pr_title_match.group(1).strip()
+        pr_body = pr_body_match.group(1).strip() if pr_body_match else ""
+        summary = f"{pr_title}\n\n{pr_body}".strip() if pr_body else pr_title
+    elif not summary:
+        # Fallback: build a minimal summary from file lists
+        parts = []
+        if files_created:
+            parts.append(f"Created: {', '.join(sorted(files_created))}")
+        if files_modified:
+            parts.append(f"Modified: {', '.join(sorted(files_modified))}")
+        summary = ". ".join(parts) if parts else "No changes produced."
 
     result = {
         "completed": len(errors) == 0,
@@ -935,24 +1060,27 @@ def main():
     if machine_id:
         client_kwargs["default_headers"] = {"X-Machine-Id": machine_id}
     client = OpenAI(**client_kwargs)
-    system = SYSTEM_PROMPT.format(cwd=os.getcwd(), approach=APPROACH_BLOCK)
+    cwd = os.getcwd()
 
     # Load codebase map if available
+    map_suffix = ""
     map_file = Path.cwd() / ".coder" / "map.md"
     if map_file.exists():
         try:
             map_content = map_file.read_text(encoding="utf-8").strip()
             if len(map_content) > 20000:
-                map_content = map_content[:20000] + "\n\n... (map truncated — use list_files to explore further)"
-            system += f"\n\n{map_content}"
+                map_content = map_content[:20000] + "\n\n... (map truncated -- use list_files to explore further)"
+            map_suffix = f"\n\n{map_content}"
             print(f"{C.DIM}Loaded codebase map ({map_content.count(chr(10))} lines){C.RESET}", file=sys.stderr)
         except OSError:
             pass
 
     # ── Headless prompt mode ────────────────────────────────────────────
     if args.prompt:
+        plan_system = PLAN_PROMPT.format(cwd=cwd) + map_suffix
+        exec_system = EXEC_PROMPT.format(cwd=cwd) + map_suffix
         try:
-            result = run_prompt(client, args.prompt, system)
+            result = run_prompt(client, args.prompt, plan_system, exec_system)
             print(json.dumps(result, indent=2))
             sys.exit(0 if result["completed"] else 1)
         except Exception as e:
@@ -977,6 +1105,7 @@ def main():
             sys.exit(130)
 
     # ── Interactive REPL mode ───────────────────────────────────────────
+    system = REPL_PROMPT.format(cwd=cwd) + map_suffix
     messages = []
 
     mode_label = f" {C.YELLOW}(safe mode){C.RESET}" if SAFE_MODE else ""