claude-teammate 0.1.63 → 0.1.65

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-teammate",
-  "version": "0.1.63",
+  "version": "0.1.65",
   "description": "CLI bootstrapper for Claude Teammate.",
   "license": "MIT",
   "type": "module",

package/src/claude.js

@@ -192,6 +192,45 @@ const EPIC_MEMORY_CLEANUP_SCHEMA = {
   required: ["facts", "guardrails"]
 };
 
+const CODE_CHANGE_DECISION_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    verdict: {
+      type: "string",
+      enum: ["needs_code", "no_code"]
+    }
+  },
+  required: ["verdict"]
+};
+
+const NO_CODE_TASK_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    result: {
+      type: "string",
+      enum: ["completed", "failed"]
+    },
+    summary: {
+      type: "string"
+    },
+    epic_facts: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    },
+    epic_guardrails: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    }
+  },
+  required: ["result", "summary", "epic_facts", "epic_guardrails"]
+};
+
 export async function runClaudeClarification(input) {
   if (!Array.isArray(input.repoPaths) || input.repoPaths.length === 0) {
     throw new Error("Claude clarification requires at least one local repository path.");
@@ -451,6 +490,84 @@ export async function runClaudeEpicMemorySummarize(input) {
   return validateEpicMemoryCleanupResult(parseClaudeOutput(stdout));
 }
 
+export async function runClaudeCodeChangeDecision(input) {
+  if (!Array.isArray(input.repoPaths) || input.repoPaths.length === 0) {
+    throw new Error("Claude code change decision requires at least one local repository path.");
+  }
+
+  const args = [
+    "--print",
+    "--model",
+    input.model || DEFAULT_MODEL,
+    "--permission-mode",
+    resolveClaudePermissionMode(input.permissionMode),
+    "--effort",
+    "low",
+    "--output-format",
+    "json",
+    "--json-schema",
+    JSON.stringify(CODE_CHANGE_DECISION_SCHEMA),
+    "--append-system-prompt",
+    buildCodeChangeDecisionSystemPrompt(),
+    buildCodeChangeDecisionUserPrompt(input)
+  ];
+
+  let stdout;
+  const workingDirectory = getClaudeWorkspaceRoot(input.repoPaths);
+
+  try {
+    ({ stdout } = await runClaudeCommand("claude", args, {
+      cwd: workingDirectory,
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: input.timeoutMs || DEFAULT_TIMEOUT_MS
+    }));
+  } catch (error) {
+    throw new Error(formatClaudeInvocationError(error, input.timeoutMs || DEFAULT_TIMEOUT_MS));
+  }
+
+  return validateCodeChangeDecisionResult(parseClaudeOutput(stdout));
+}
+
+export async function runClaudeNoCodeTask(input) {
+  if (!Array.isArray(input.repoPaths) || input.repoPaths.length === 0) {
+    throw new Error("Claude no-code task requires at least one local repository path.");
+  }
+
+  const repoPaths = [...new Set(input.repoPaths.map((repoPath) => path.resolve(repoPath)))];
+
+  const args = [
+    "--print",
+    "--model",
+    input.model || DEFAULT_MODEL,
+    "--permission-mode",
+    resolveClaudePermissionMode(input.permissionMode),
+    "--effort",
+    "medium",
+    "--output-format",
+    "json",
+    "--json-schema",
+    JSON.stringify(NO_CODE_TASK_SCHEMA),
+    "--append-system-prompt",
+    buildNoCodeTaskSystemPrompt(),
+    buildNoCodeTaskUserPrompt(input)
+  ];
+
+  let stdout;
+
+  try {
+    ({ stdout } = await runClaudeCommand("claude", args, {
+      cwd: getClaudeWorkspaceRoot(repoPaths),
+      maxBuffer: 10 * 1024 * 1024,
+      timeout: input.timeoutMs || 30 * 60 * 1000,
+      onSpawn: input.onSpawn
+    }));
+  } catch (error) {
+    throw new Error(formatClaudeInvocationError(error, input.timeoutMs || 30 * 60 * 1000));
+  }
+
+  return validateNoCodeTaskResult(parseClaudeOutput(stdout));
+}
+
 export async function runClaudeImplementation(input) {
   if (!input.repoPath) {
     throw new Error("Claude implementation requires a local repository path.");
@@ -605,6 +722,14 @@ export function parseClaudeOutput(output) {
       return direct;
     }
 
+    if ("verdict" in direct) {
+      return direct;
+    }
+
+    if ("result" in direct && "summary" in direct) {
+      return direct;
+    }
+
     if ("result" in direct && typeof direct.result === "string") {
       return JSON.parse(direct.result);
     }
@@ -753,6 +878,35 @@ function validateEpicMemoryCleanupResult(result) {
   };
 }
 
+function validateCodeChangeDecisionResult(result) {
+  if (!result || typeof result !== "object" || !["needs_code", "no_code"].includes(result.verdict)) {
+    throw new Error("Claude CLI returned an invalid code change decision payload.");
+  }
+
+  return { verdict: result.verdict };
+}
+
+function validateNoCodeTaskResult(result) {
+  if (!result || typeof result !== "object") {
+    throw new Error("Claude CLI returned an invalid no-code task payload.");
+  }
+
+  if (!["completed", "failed"].includes(result.result)) {
+    throw new Error("Claude CLI returned an unsupported no-code task result.");
+  }
+
+  return {
+    result: result.result,
+    summary: String(result.summary ?? "").trim(),
+    epic_facts: Array.isArray(result.epic_facts)
+      ? result.epic_facts.map((item) => String(item).trim()).filter(Boolean)
+      : [],
+    epic_guardrails: Array.isArray(result.epic_guardrails)
+      ? result.epic_guardrails.map((item) => String(item).trim()).filter(Boolean)
+      : []
+  };
+}
+
 function formatClaudeInvocationError(error, timeoutMs) {
   const stderr = error instanceof Error && "stderr" in error ? String(error.stderr || "") : "";
   const output = error instanceof Error && "stdout" in error ? String(error.stdout || "") : "";
@@ -895,6 +1049,69 @@ function terminateChildProcess(child) {
   });
 }
 
+function buildCodeChangeDecisionSystemPrompt() {
+  return [
+    "You are deciding whether a Jira task requires code changes.",
+    "Read the issue description and memory snapshot carefully.",
+    "Output verdict=needs_code if the task involves modifying, adding, or removing code in any repository.",
+    "Output verdict=no_code if the task can be completed without any code changes (e.g. documentation lookup, research, answering questions, configuration through UI, or purely informational tasks).",
+    "The decision must be deterministic based on the information provided.",
+    "Return only structured output matching the provided schema."
+  ].join(" ");
+}
+
+function buildCodeChangeDecisionUserPrompt(input) {
+  return `Decide whether this Jira task requires code changes.
+
+Issue key: ${input.issue.key}
+Issue URL: ${input.issue.url}
+Summary: ${input.issue.summary}
+Status: ${input.issue.status}
+Description:
+${input.issue.descriptionText || "(none)"}
+
+Memory snapshot:
+${JSON.stringify(input.memory, null, 2)}
+
+Output verdict=needs_code if code changes are required, or verdict=no_code if the task can be completed without any code changes.`;
+}
+
+function buildNoCodeTaskSystemPrompt() {
+  return [
+    "You are completing a Jira task that does not require code changes.",
+    "Read the task description and memory snapshot carefully.",
+    "You may inspect the provided repository using read-only tools if that helps complete the task.",
+    "Do not edit files, do not run mutating commands, and do not make code changes.",
+    "Read the epic memory snapshot before starting so you can apply known repo-specific knowledge.",
+    "When writing repo-specific epic memory, include a short repo label in the text itself using the shortest unambiguous name or abbreviation you can derive from the repo URL or local path, for example `landing:` or `claude-teammate:`.",
+    "Do not add a repo label for epic-wide product, business, or workflow knowledge that is not tied to one codebase.",
+    "Do not restate Jira URLs, repo URLs, repo paths, or other epic facts that are already stored separately from the memory bullets.",
+    "Do not store obvious facts, generic advice, or one-off ticket details in epic memory.",
+    "Return result=completed with a summary of what was accomplished, or result=failed with a summary of why it could not be completed.",
+    "Return epic_facts and epic_guardrails only for reusable non-obvious repo or epic knowledge discovered during this task.",
+    "Return only structured output matching the provided schema."
+  ].join(" ");
+}
+
+function buildNoCodeTaskUserPrompt(input) {
+  return `Complete this Jira task.
+
+Issue key: ${input.issue.key}
+Issue URL: ${input.issue.url}
+Summary: ${input.issue.summary}
+Status: ${input.issue.status}
+Description:
+${input.issue.descriptionText || "(none)"}
+
+Memory snapshot:
+${JSON.stringify(input.memory, null, 2)}
+
+Repository paths:
+${input.repoPaths.join("\n")}
+
+Complete the task and return result=completed with a summary, or result=failed with an explanation.`;
+}
+
 function buildJiraClarificationSystemPrompt() {
   return [
     "You are clarifying a Jira ticket for an implementation planning workflow.",

package/src/commands/worker.js

@@ -5,9 +5,11 @@ import process from "node:process";
 import {
   cleanupClaudeProcesses,
   runClaudeClarification,
+  runClaudeCodeChangeDecision,
   runClaudeEpicMemoryCleanup,
   runClaudeEpicMemorySummarize,
   runClaudeImplementation,
+  runClaudeNoCodeTask,
   runClaudePrReview,
   runClaudePullRequestCommentReview,
   runClaudeGitHubIssueReview
@@ -695,6 +697,83 @@ async function processJiraIssue({ issue, jira, github, botUser, config, projectR
       issue: detail.key,
       repos: epicMemory.repos.length
     });
+
+    if (!issueMemory.code_change_verdict) {
+      let decisionResult;
+      try {
+        decisionResult = await runClaudeCodeChangeDecision({
+          issue: detail,
+          memory: { epic: buildEpicMemoryPromptSnapshot(epicMemory) },
+          repoPaths: epicMemory.repos.map((repo) => repo.local_path).filter(Boolean),
+          permissionMode: config.CLAUDE_PERMISSION_MODE,
+          timeoutMs: parseOptionalInt(config.CLAUDE_TIMEOUT_MS)
+        });
+      } catch (error) {
+        issueMemory.last_error = error instanceof Error ? error.message : String(error);
+        issueMemory = await saveIssueMemory(issueMemoryRecord.filePath, detail, issueMemory);
+        await logger.error("Claude code change decision failed", { issue: detail.key, error });
+        return buildIssueState(detail, epicMemory, issueMemory, null, issueMemory.last_error);
+      }
+      issueMemory.code_change_verdict = decisionResult.verdict;
+      issueMemory = await saveIssueMemory(issueMemoryRecord.filePath, detail, issueMemory);
+      await logger.info("Code change decision made", {
+        issue: detail.key,
+        verdict: decisionResult.verdict
+      });
+    }
+
+    if (issueMemory.code_change_verdict === "no_code") {
+      if (!issueMemory.no_code_result) {
+        let taskResult = null;
+        try {
+          taskResult = await runClaudeNoCodeTask({
+            issue: detail,
+            memory: { epic: buildEpicMemoryPromptSnapshot(epicMemory) },
+            repoPaths: epicMemory.repos.map((repo) => repo.local_path).filter(Boolean),
+            permissionMode: config.CLAUDE_PERMISSION_MODE,
+            timeoutMs: parseOptionalInt(config.CLAUDE_TIMEOUT_MS)
+          });
+        } catch (error) {
+          issueMemory.no_code_result = "failed";
+          issueMemory.no_code_summary = error instanceof Error ? error.message : String(error);
+          issueMemory.workflow_state = "failed";
+          issueMemory = await saveIssueMemory(issueMemoryRecord.filePath, detail, issueMemory);
+          await logger.error("Claude no-code task failed", { issue: detail.key, error });
+        }
+        if (taskResult) {
+          epicMemory = await saveMaintainedEpicMemory({
+            filePath: epicMemoryRecord.filePath,
+            issue: detail,
+            epicMemory,
+            projectRoot,
+            permissionMode: config.CLAUDE_PERMISSION_MODE,
+            timeoutMs: parseOptionalInt(config.CLAUDE_TIMEOUT_MS),
+            reason: "Updated epic memory from no-code task execution.",
+            candidateUpdates: {
+              epic_facts: taskResult.epic_facts || [],
+              epic_guardrails: taskResult.epic_guardrails || []
+            },
+            logger
+          });
+          issueMemory.no_code_result = taskResult.result;
+          issueMemory.no_code_summary = taskResult.summary;
+          issueMemory.workflow_state = taskResult.result === "completed" ? "completed" : "failed";
+          issueMemory = await saveIssueMemory(issueMemoryRecord.filePath, detail, issueMemory);
+          await logger.info("No-code task finished", {
+            issue: detail.key,
+            result: taskResult.result
+          });
+        }
+      }
+
+      const resultComment = issueMemory.no_code_result === "completed"
+        ? `Completed: ${issueMemory.no_code_summary}`
+        : `Failed: ${issueMemory.no_code_summary}`;
+      await ensureJiraComment(detail, jira, botUser, resultComment);
+      issueMemory = await saveIssueMemory(issueMemoryRecord.filePath, detail, issueMemory);
+      return buildIssueState(detail, epicMemory, issueMemory, "no_code");
+    }
+
     issueMemory = await continueGitHubIssueCreation({
       detail,
       jira,

package/src/dashboard/ui.html

@@ -503,9 +503,15 @@ tr:last-child td { border-bottom:none; }
 tr:hover td { background:var(--bg); }
 
 /* ── Pipeline ── */
+.pipeline-scroll {
+  overflow-x: auto;
+}
+
 .pipeline {
   display:grid;
-  grid-template-columns:repeat(auto-fill,minmax(200px,1fr));
+  grid-auto-flow: column;
+  grid-auto-columns: minmax(200px, 1fr);
+  min-width: max-content;
   gap:14px;
   margin-bottom:4px;
 }
@@ -1370,8 +1376,10 @@ tr.clickable:hover td { background:var(--sky-bg) !important; }
         </div>
         <button class="btn" onclick="refreshAll()">↻ Refresh</button>
       </div>
-      <div class="pipeline" id="pipeline-view">
-        <div class="empty"><div class="empty-icon">▸</div><div class="empty-text">Loading…</div></div>
+      <div class="pipeline-scroll">
+        <div class="pipeline" id="pipeline-view">
+          <div class="empty"><div class="empty-icon">▸</div><div class="empty-text">Loading…</div></div>
+        </div>
       </div>
     </div>