@link-assistant/hive-mind 1.27.0 → 1.29.0

package/CHANGELOG.md

@@ -1,5 +1,47 @@
 # @link-assistant/hive-mind
 
+## 1.29.0
+
+### Minor Changes
+
+- 161b595: feat: add --auto-accept-invite option to solve command
+
+  Adds a new `--auto-accept-invite` boolean option to the `solve` command that automatically accepts the pending GitHub repository or organization invitation for the specific repository/organization being solved, before checking write access.
+
+  Unlike the `/accept_invites` Telegram command (which accepts ALL pending invitations), this option is scoped to the target repo/org only, making it safer and more targeted. Useful when you've just been invited to a repository and want to run `solve` without manually accepting the invitation first.
+
+## 1.28.0
+
+### Minor Changes
+
+- docs: expand best practices with CI/CD guide, universal prompts, and architecture improvement (Issue #1403)
+
+  Splits the existing `docs/BEST-PRACTICES.md` into two focused documents:
+  - **`docs/CI-CD-BEST-PRACTICES.md`** (renamed from the original) — Updated and expanded CI/CD guide covering all key points from existing workflow templates, including: running checks only on relevant file changes, fast-fail job ordering, fresh merge simulation, concurrency control, changeset exemptions for docs-only PRs, secrets detection, documentation validation, and OIDC trusted publishing.
+  - **`docs/BEST-PRACTICES.md`** (new general guide) — Universal best practices for AI-driven development including: deep analysis bug/feature prompts, universal validation prompt, plan mode prompt, issue writing guidelines with acceptance criteria patterns, an architecture improvement prompt linking to the Code Architecture Principles repository, CI/CD summary with link to the CI/CD guide, and subagent coordination patterns.
+
+  Also updates `README.md` to link to both new documents in the Best Practices section.
+
+  feat: enable --auto-restart-until-mergeable by default (Issue #1360)
+
+  The `--auto-restart-until-mergeable` feature has become stable enough to be enabled by default. Previously, users had to explicitly pass this flag to enable automatic restart until the PR becomes mergeable.
+
+  Now the feature is enabled by default, meaning the solver will automatically restart on new comments from non-bot users, CI failures, merge conflicts, or other issues — without requiring any extra flags. Users who want to disable this behavior can pass `--no-auto-restart-until-mergeable`.
+
+  fix: filter GitHub Pages deployment workflows from PR CI check (Issue #1399)
+
+  `getActiveRepoWorkflows()` included the `pages-build-deployment` workflow (path: `dynamic/pages/pages-build-deployment`) as if it were a PR CI workflow. This workflow is auto-created by GitHub for GitHub Pages and only runs on the default branch after merge — it never creates check-runs on PR branches. As a result, `--auto-restart-until-mergeable` got stuck in an infinite loop waiting for CI checks that would never appear.
+
+  The fix filters out workflows with the `dynamic/pages/` prefix from `getActiveRepoWorkflows()`. These are GitHub Pages internal workflows, not user-defined CI pipelines.
+
+  Affected scenario: repositories with GitHub Pages enabled but no `.github/workflows/` files (e.g., `konard/links-visuals`).
+
+  fix: resolve Prettier formatting issue in README.md (Issue #1401)
+
+  The CI/CD `lint` job was failing on the `main` branch because README.md had Prettier formatting violations after commit `da376061` ("Clarify Time Freedom and Any Device Programming features"). That commit added longer text to two table cells, which made the table column widths inconsistent with Prettier's expected format.
+
+  The fix runs `prettier --write` on README.md to re-align the table column widths, bringing the file back into conformance with the `format:check` CI step.
+
 ## 1.27.0
 
 ### Minor Changes

package/README.md

@@ -21,18 +21,18 @@ Inspired by [konard/problem-solving](https://github.com/konard/problem-solving)
 
 Hive Mind is a **generalist AI** (mini-AGI) capable of working on a wide range of tasks - not just programming. Almost anything that can be done with files in a repository can be automated.
 
-| Feature                      | What It Means For You                                                                              |
-| ---------------------------- | -------------------------------------------------------------------------------------------------- |
-| **No Babysitting**           | Full autonomous mode with sudo access. AI has creative freedom like a real programmer.             |
-| **Cloud Isolation**          | Runs on dedicated VMs or Docker. Easy to restore if broken.                                        |
-| **Full Internet + Sudo**     | AI can install packages, fetch docs, and configure the system as needed.                           |
-| **Pre-installed Toolchain**  | 25GB+ ready: 10 language runtimes, 2 theorem provers, build tools. Can install more.               |
-| **Token Efficiency**         | Routine tasks automated in code, so AI tokens focus on creative problem-solving.                   |
-| **Time Freedom**             | What takes humans 2-8 hours, AI completes in 10-25 minutes. "The code is written while you sleep." |
-| **Scale with Orchestration** | Parallel workers feel like a team of developers, all for ~$200/month.                              |
-| **Human Control**            | AI creates draft PRs - you decide what merges. Quality gates where they matter.                    |
-| **Any Device Programming**   | Manage AI from any device with `/solve` and `/hive`. No PC, IDE, or laptop required.               |
-| **100% Open Source**         | Unlicense (public domain). Full transparency, no vendor lock-in.                                   |
+| Feature                      | What It Means For You                                                                                                                                                      |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **No Babysitting**           | Full autonomous mode with sudo access. AI has creative freedom like a real programmer.                                                                                     |
+| **Cloud Isolation**          | Runs on dedicated VMs or Docker. Easy to restore if broken.                                                                                                                |
+| **Full Internet + Sudo**     | AI can install packages, fetch docs, and configure the system as needed.                                                                                                   |
+| **Pre-installed Toolchain**  | 25GB+ ready: 10 language runtimes, 2 theorem provers, build tools. Can install more.                                                                                       |
+| **Token Efficiency**         | Routine tasks automated in code, so AI tokens focus on creative problem-solving.                                                                                           |
+| **Time Freedom**             | What takes humans 2-8 hours, AI completes each working session in 10-25 minutes. Mass execution of tasks in repository is possible. "The code is written while you sleep." |
+| **Scale with Orchestration** | Parallel workers feel like a team of developers, all for ~$200/month.                                                                                                      |
+| **Human Control**            | AI creates draft PRs - you decide what merges. Quality gates where they matter.                                                                                            |
+| **Any Device Programming**   | Manage AI from any device with `/solve` and `/hive` via Telegram bot. No PC, IDE, or laptop required.                                                                      |
+| **100% Open Source**         | Unlicense (public domain). Full transparency, no vendor lock-in.                                                                                                           |
 
 > _"Compared to Codex for $200, this solution is fire."_ - User feedback
 
@@ -404,9 +404,9 @@ The Hive Mind includes a Telegram bot interface (SwarmMindBot) for remote comman
 
 ### 🚀 Test Drive
 
-Want to see the Hive Mind in action? Join our Telegram channel where you can execute the Hive Mind on your own issues and watch AI solve them:
+Want to see the Hive Mind in action? Request a free demo or get faster support by messaging the developer directly on Telegram:
 
-**[Join https://t.me/hive_mind_pull_requests](https://t.me/hive_mind_pull_requests)**
+**[Message @drakonard on Telegram](https://t.me/drakonard)**
 
 ### Setup
 
@@ -839,6 +839,30 @@ screen -wipe
 screen -ls
 ```
 
+### Top with full arguments of each command
+
+```bash
+top -c
+```
+
+### See the full tree of processes
+
+```bash
+ps -eo pid,ppid,user,args --forest
+```
+
+or
+
+```bash
+ps axjf
+```
+
+### Kill all commands spawned by specific task
+
+```bash
+pkill -f gh-issue-solver-1773073065743
+```
+
 That can be done, but not recommended as reboot have better effect.
 
 ## 📄 License
@@ -847,7 +871,10 @@ Unlicense License - see [LICENSE](./LICENSE)
 
 ## 🏆 Best Practices
 
-Hive Mind works even better when repositories have strong CI/CD pipelines. See [BEST-PRACTICES.md](./docs/BEST-PRACTICES.md) for recommended configurations that maximize AI solver quality.
+Hive Mind works even better when repositories have strong CI/CD pipelines and clear issue requirements. See:
+
+- [BEST-PRACTICES.md](./docs/BEST-PRACTICES.md) — Universal prompts, issue writing guidelines, architecture improvement, and subagent patterns
+- [CI-CD-BEST-PRACTICES.md](./docs/CI-CD-BEST-PRACTICES.md) — CI/CD pipeline setup, recommended templates, and enforcement strategies
 
 Key benefits of proper CI/CD:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.27.0",
+  "version": "1.29.0",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/github-merge.lib.mjs

@@ -1403,20 +1403,31 @@ export async function getWorkflowRunsForSha(owner, repo, sha, verbose = false) {
  * When a repo has NO workflows, no_checks means no CI configured.
  * When a repo HAS workflows, no_checks means CI checks haven't started yet (race condition).
  *
+ * Issue #1399: GitHub Pages deployment workflows (path: "dynamic/pages/...") are excluded
+ * because they only run on the default branch after merge, never on PR branches. Counting
+ * them as "CI workflows" causes an infinite loop waiting for check-runs that never appear.
+ *
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
  * @param {boolean} verbose - Whether to log verbose output
- * @returns {Promise<{count: number, hasWorkflows: boolean, workflows: Array<{id: number, name: string, state: string}>}>}
+ * @returns {Promise<{count: number, hasWorkflows: boolean, workflows: Array<{id: number, name: string, state: string, path: string}>}>}
  */
 export async function getActiveRepoWorkflows(owner, repo, verbose = false) {
   try {
-    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/workflows" --jq '[.workflows[] | select(.state == "active")] | map({id: .id, name: .name, state: .state})'`);
-    const workflows = JSON.parse(stdout.trim() || '[]');
+    const { stdout } = await exec(`gh api "repos/${owner}/${repo}/actions/workflows" --jq '[.workflows[] | select(.state == "active")] | map({id: .id, name: .name, state: .state, path: .path})'`);
+    const allWorkflows = JSON.parse(stdout.trim() || '[]');
+
+    // Issue #1399: Filter out GitHub Pages deployment workflows.
+    // These have path "dynamic/pages/pages-build-deployment" and only run on the
+    // default branch after merge — they never produce check-runs on PR branches.
+    // Including them causes an infinite loop when waiting for PR CI checks.
+    const workflows = allWorkflows.filter(wf => !wf.path.startsWith('dynamic/pages/'));
 
     if (verbose) {
-      console.log(`[VERBOSE] /merge: Found ${workflows.length} active workflows in ${owner}/${repo}`);
-      for (const wf of workflows) {
-        console.log(`[VERBOSE] /merge:   - ${wf.name} (${wf.id}): ${wf.state}`);
+      console.log(`[VERBOSE] /merge: Found ${allWorkflows.length} active workflows in ${owner}/${repo} (${workflows.length} PR-relevant after filtering out GitHub Pages deployment workflows)`);
+      for (const wf of allWorkflows) {
+        const filtered = wf.path.startsWith('dynamic/pages/');
+        console.log(`[VERBOSE] /merge:   - ${wf.name} (${wf.id}): ${wf.state}, path=${wf.path}${filtered ? ' [excluded: GitHub Pages deployment]' : ''}`);
       }
     }
 

package/src/solve.accept-invite.lib.mjs

@@ -0,0 +1,89 @@
+/**
+ * Auto-accept GitHub invitation for a specific repository/organization.
+ *
+ * Unlike the /accept_invites Telegram command (which accepts ALL pending invitations),
+ * this module only accepts the invitation for the specific repository or organization
+ * that is being solved. This is safer and more targeted.
+ *
+ * @see https://docs.github.com/en/rest/collaborators/invitations
+ * @see https://docs.github.com/en/rest/orgs/members
+ * @see https://github.com/link-assistant/hive-mind/issues/1373
+ */
+
+import { promisify } from 'util';
+import { exec as execCallback } from 'child_process';
+
+const exec = promisify(execCallback);
+
+/**
+ * Accepts pending GitHub repository or organization invitation for a specific target.
+ *
+ * Checks for a pending repository invitation matching `owner/repo` and/or a pending
+ * organization membership for `owner`. Accepts only the matching invitation(s).
+ *
+ * @param {string} owner - Repository owner (user or organization login)
+ * @param {string} repo - Repository name
+ * @param {Function} log - Logging function
+ * @param {boolean} verbose - Whether verbose logging is enabled
+ * @returns {Promise<{acceptedRepo: boolean, acceptedOrg: boolean}>} Result of acceptance attempts
+ */
+export async function autoAcceptInviteForRepo(owner, repo, log, verbose) {
+  const result = { acceptedRepo: false, acceptedOrg: false };
+  const fullName = `${owner}/${repo}`;
+
+  await log(`🔍 --auto-accept-invite: Checking for pending invitation to ${fullName}...`);
+
+  // Check for pending repository invitation
+  try {
+    const { stdout: repoInvJson } = await exec('gh api /user/repository_invitations 2>/dev/null || echo "[]"');
+    const repoInvitations = JSON.parse(repoInvJson.trim() || '[]');
+    verbose && (await log(`   Found ${repoInvitations.length} total pending repo invitation(s)`, { verbose: true }));
+
+    const matchingInv = repoInvitations.find(inv => inv.repository?.full_name?.toLowerCase() === fullName.toLowerCase());
+
+    if (matchingInv) {
+      try {
+        await exec(`gh api -X PATCH /user/repository_invitations/${matchingInv.id}`);
+        await log(`✅ --auto-accept-invite: Accepted repository invitation for ${fullName}`);
+        result.acceptedRepo = true;
+      } catch (e) {
+        await log(`⚠️  --auto-accept-invite: Failed to accept repository invitation for ${fullName}: ${e.message}`, { level: 'warning' });
+      }
+    } else {
+      verbose && (await log(`   No pending repository invitation found for ${fullName}`, { verbose: true }));
+    }
+  } catch (e) {
+    verbose && (await log(`   Could not fetch repository invitations: ${e.message}`, { verbose: true }));
+  }
+
+  // Check for pending organization membership
+  try {
+    const { stdout: orgMemJson } = await exec('gh api /user/memberships/orgs 2>/dev/null || echo "[]"');
+    const orgMemberships = JSON.parse(orgMemJson.trim() || '[]');
+    const pendingOrgs = orgMemberships.filter(m => m.state === 'pending');
+    verbose && (await log(`   Found ${pendingOrgs.length} total pending org invitation(s)`, { verbose: true }));
+
+    const matchingOrg = pendingOrgs.find(m => m.organization?.login?.toLowerCase() === owner.toLowerCase());
+
+    if (matchingOrg) {
+      const orgName = matchingOrg.organization.login;
+      try {
+        await exec(`gh api -X PATCH /user/memberships/orgs/${orgName} -f state=active`);
+        await log(`✅ --auto-accept-invite: Accepted organization invitation for ${orgName}`);
+        result.acceptedOrg = true;
+      } catch (e) {
+        await log(`⚠️  --auto-accept-invite: Failed to accept organization invitation for ${orgName}: ${e.message}`, { level: 'warning' });
+      }
+    } else {
+      verbose && (await log(`   No pending organization invitation found for ${owner}`, { verbose: true }));
+    }
+  } catch (e) {
+    verbose && (await log(`   Could not fetch organization memberships: ${e.message}`, { verbose: true }));
+  }
+
+  if (!result.acceptedRepo && !result.acceptedOrg) {
+    await log(`ℹ️  --auto-accept-invite: No pending invitation found for ${fullName} or organization ${owner}`);
+  }
+
+  return result;
+}

package/src/solve.config.lib.mjs

@@ -179,7 +179,7 @@ export const SOLVE_OPTION_DEFINITIONS = {
   'auto-restart-until-mergeable': {
     type: 'boolean',
     description: 'Auto-restart until PR becomes mergeable (no iteration limit). Restarts on new comments from non-bot users, CI failures, merge conflicts, or other issues. Does NOT auto-merge.',
-    default: false,
+    default: true,
   },
   'auto-restart-on-non-updated-pull-request-description': {
     type: 'boolean',
@@ -369,6 +369,11 @@ export const SOLVE_OPTION_DEFINITIONS = {
     description: 'Automatically attach solution summary only if the AI did not create any comments during the session. This provides visible feedback when the AI completes silently.',
     default: false,
   },
+  'auto-accept-invite': {
+    type: 'boolean',
+    description: 'Automatically accept the pending GitHub repository or organization invitation for the specific repository/organization being solved, before checking write access. Unlike /accept_invites which accepts all pending invitations, this only accepts the invite for the target repo/org.',
+    default: false,
+  },
 };
 
 // Function to create yargs configuration - avoids duplication

package/src/solve.mjs

@@ -94,6 +94,8 @@ const { prepareFeedbackAndTimestamps, checkUncommittedChanges, checkForkActions
 // Import model validation library
 const modelValidation = await import('./model-validation.lib.mjs');
 const { validateAndExitOnInvalidModel } = modelValidation;
+const acceptInviteLib = await import('./solve.accept-invite.lib.mjs');
+const { autoAcceptInviteForRepo } = acceptInviteLib;
 
 // Initialize log file EARLY to capture all output including version and command
 // Use default directory (cwd) initially, will be set from argv.logDir after parsing
@@ -313,6 +315,11 @@ if (argv.autoFork && !argv.fork) {
   }
 }
 
+// Accept pending GitHub invitation for the specific repo/org before checking write access
+if (argv.autoAcceptInvite) {
+  await autoAcceptInviteForRepo(owner, repo, log, argv.verbose);
+}
+
 // Early check: Verify repository write permissions BEFORE doing any work
 // This prevents wasting AI tokens when user doesn't have access and --fork is not used
 const { checkRepositoryWritePermission } = githubLib;