@yemi33/minions 0.1.2217 → 0.1.2218

package/dashboard.js

@@ -13033,6 +13033,36 @@ What would you like to discuss or change? When you're happy, say "approve" and I
       }
     }},
 
+    { method: 'POST', path: '/api/pr-action/offer-create-pr', desc: 'Offer a "Create PR" follow-up chip after Command Center makes a LOCAL code edit itself in a configured project (P-cc-createpr). Validates the project has uncommitted working-tree changes (git status --porcelain in project.localPath) and returns a create-pr follow-up chip — same CC-mediated shape as the pr-action chips, so the existing dashboard chip renderer/click handler light up unchanged. Returns {ok, hasChanges, branch, changedFileCount, followups}; followups is [] when there is nothing to PR. READ-ONLY: never stages/commits/pushes — clicking the chip routes a fresh CC turn that does the commit/push/PR-create/link.', params: 'project (configured project name), branch (optional — defaults to the working-tree current branch), contextOnly (optional bool — link the new PR as context-only instead of auto-managed)', handler: async (req, res) => {
+      const body = await readBody(req);
+      try {
+        reloadConfig();
+        const projectName = typeof body?.project === 'string' ? body.project.trim() : '';
+        if (!projectName) return jsonReply(res, 400, { error: 'project is required' }, req);
+        const project = shared.getProjects(CONFIG).find(p => p && p.name === projectName);
+        if (!project) return jsonReply(res, 404, { error: `unknown project: ${projectName}` }, req);
+        if (!project.localPath) return jsonReply(res, 400, { error: `project ${projectName} has no localPath (no working tree to PR)` }, req);
+        let porcelain = '';
+        let currentBranch = '';
+        try {
+          porcelain = await shared.shellSafeGit(['-C', project.localPath, 'status', '--porcelain']);
+          currentBranch = (await shared.shellSafeGit(['-C', project.localPath, 'rev-parse', '--abbrev-ref', 'HEAD'])).trim();
+        } catch (e) {
+          return jsonReply(res, 400, { error: `git status failed for ${projectName}: ${e.message}` }, req);
+        }
+        const changedFileCount = porcelain.split('\n').map(s => s.trim()).filter(Boolean).length;
+        const hasChanges = changedFileCount > 0;
+        const branch = (typeof body?.branch === 'string' && body.branch.trim()) || currentBranch || '';
+        const followups = hasChanges
+          ? prAction.buildCreatePrFollowups({ project: projectName, branch, contextOnly: !!body?.contextOnly })
+          : [];
+        recordCcTurnIfPresent(req, { kind: 'pr-action', id: '', title: `offer create-pr (${projectName})`, project: projectName, followups });
+        return jsonReply(res, 200, { ok: true, hasChanges, branch, changedFileCount, followups }, req);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message }, req);
+      }
+    }},
+
     { method: 'POST', path: '/api/pull-requests/observe', desc: 'Toggle canonical contextOnly flag on a tracked PR (public `observe` body param is preserved as the inverse for backward compat)', params: 'host (github|ado), slug, number, observe (boolean)', handler: async (req, res) => {
       const body = await readBody(req);
       reloadConfig();

package/engine/pr-action.js

@@ -128,6 +128,50 @@ function buildPrActionFollowups(record, opts = {}) {
   }));
 }
 
+// ── "Create PR" follow-up (P-cc-createpr) ───────────────────────────────────
+// Offered after Command Center makes a LOCAL code edit itself (not via a
+// dispatched agent), so the user can open a PR for it with one click. Mirrors
+// the PR_ACTION_FOLLOWUPS chip shape ({ kind, label, message }) so the existing
+// dashboard renderer (_ccFollowupChips) + click handler (ccPrActionFollowup)
+// light up unchanged. CC-mediated by the same deliberate design as the
+// pr-action chips: clicking sends a fresh CC turn that commits/pushes/opens the
+// PR and links it to the tracker — no new server-side git path, maximal reuse.
+const CREATE_PR_FOLLOWUP = Object.freeze({ kind: 'create-pr', label: 'Create PR' });
+
+/**
+ * Build the "Create PR" follow-up chip(s) for a working-tree change CC just
+ * made in `project`. Returns `[]` when no project is given (nothing to act on).
+ *
+ * `branch`       — the working-tree branch to commit on; falls back to "a new
+ *                  well-named branch" wording when absent.
+ * `contextOnly`  — when true, the chip links the new PR as context-only instead
+ *                  of auto-managed (the default is auto-managed / contextOnly:false).
+ *
+ * Each chip: `{ kind:'create-pr', label, project, branch, message }` where
+ * `message` is the Command Center turn the chip click should send.
+ */
+function buildCreatePrFollowups({ project, branch, contextOnly = false } = {}) {
+  const proj = (project && String(project).trim()) || '';
+  if (!proj) return [];
+  const br = branch && String(branch).trim() ? String(branch).trim() : '';
+  const branchClause = br
+    ? `on the current branch ${br}`
+    : 'on a new well-named branch off the project main branch';
+  const linkBody = contextOnly
+    ? `{"url":"<new PR url>","project":"${proj}","contextOnly":true}`
+    : `{"url":"<new PR url>","project":"${proj}","contextOnly":false}`;
+  const trackNote = contextOnly
+    ? 'so it is tracked but not auto-reviewed'
+    : 'so the engine auto-manages it (review -> fix -> re-review -> auto-merge)';
+  const message =
+    `Create a PR from the local changes you just made in the ${proj} project. ` +
+    `Steps: (1) in that project's working tree, stage and commit the modified files ${branchClause} with a clear conventional-commit message; ` +
+    `(2) push the branch; (3) open a PR against the project's main branch using the right CLI for the repo host (gh for GitHub, az repos for ADO); ` +
+    `(4) link it to the tracker by calling POST /api/pull-requests/link with ${linkBody} ${trackNote}. ` +
+    `Then show me the PR URL.`;
+  return [{ kind: CREATE_PR_FOLLOWUP.kind, label: CREATE_PR_FOLLOWUP.label, project: proj, branch: br || null, message }];
+}
+
 // Read-only system prompt for the projectless dispatch. Teaches the untrusted-
 // input contract and the injection-signalling marker. Kept inline (no playbook
 // render) because this path has no project/worktree context to inject.
@@ -538,6 +582,7 @@ module.exports = {
   createPrAction,
   buildPrActionPrompt,
   buildPrActionFollowups,
+  buildCreatePrFollowups,
   runPrAction,
   postPrActionComment,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.2217",
+  "version": "0.1.2218",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"

package/prompts/cc-system.md

@@ -89,6 +89,15 @@ If you start a small task and discover it's actually Medium (3+ files, more tool
 
 When genuinely in doubt about the size, delegate — agents have isolated worktrees, full tool access, durable work-item tracking, and no turn limits.
 
+### After you make a local code edit yourself — offer to open a PR
+When you edit files **yourself** in a configured project's working tree (the Step-3 "do it yourself" path — NOT a change a dispatched agent made in its own worktree), don't leave the diff sitting uncommitted. After you finish editing, call:
+```
+curl -s -X POST http://localhost:{{dashboard_port}}/api/pr-action/offer-create-pr \
+  -H 'Content-Type: application/json' -H 'X-CC-Turn-Id: {{cc_turn_id}}' \
+  -d '{"project":"<project name>"}'
+```
+This checks the project's working tree (`git status --porcelain`) and, when there are uncommitted changes, returns a **`[Create PR]`** follow-up chip to the user (same chip mechanism as the `pr-action` `[Comment]`/`[Fix once]`/`[Track for auto-fix]` chips). When the user clicks it, you'll receive a turn instructing you to commit → push → open the PR → link it to the tracker. Pass `"contextOnly":true` if the PR should be tracked-but-not-auto-reviewed; omit it to have the engine auto-manage the PR (review → fix → re-review → auto-merge). If `hasChanges` is `false`, there's nothing to PR — skip the offer. Don't commit/push on your own initiative; surface the chip and let the user decide.
+
 ## When to dispatch vs answer inline
 
 - **Action requests** (fix this, implement that, build X, run a build, investigate Y, review PR #N) → dispatch via `POST /api/work-items` (or one of the other state-changing endpoints below). Don't also try to do the work yourself in the chat unless it's truly Small per Step 1.