@link-assistant/hive-mind 1.6.3 → 1.7.1

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # @link-assistant/hive-mind
 
+## 1.7.1
+
+### Patch Changes
+
+- d86ba79: Prevent duplicate URLs from being added to the /solve queue (Issue #1080)
+  - Added `findByUrl()` method to SolveQueue to detect existing items by URL
+  - Updated /solve command handler to check for duplicates before queueing
+  - Uses normalized URLs for consistent comparison
+  - Returns informative error message when duplicate is detected
+
+## 1.7.0
+
+### Minor Changes
+
+- 5794e2f: Add `--working-directory` / `-d` option for proper session resume
+
+  Claude Code stores sessions per-directory path, so resuming a session in a different directory fails. This change:
+  1. Adds `--working-directory` / `-d` option to solve.mjs
+     - If directory exists with git repo, uses it without cloning
+     - If directory exists but empty, clones into it
+     - If directory doesn't exist, creates it and clones
+  2. Updates `--auto-resume-on-limit-reset` to pass `--working-directory`
+     - When limit resets and session auto-resumes, it uses the same directory as the original session
+     - This ensures Claude Code can find and resume the session
+  3. Improves resume error messaging
+     - Warns when resuming without --working-directory
+     - Explains that Claude Code sessions are tied to directory paths
+
+  Example usage:
+
+  ```bash
+  ./solve.mjs "<url>" --resume <session-id> --working-directory /tmp/gh-issue-solver-123
+  ```
+
 ## 1.6.3
 
 ### Patch Changes

package/package.json

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

package/src/solve.auto-continue.lib.mjs

@@ -65,7 +65,9 @@ const formatWaitTime = ms => {
 };
 
 // Auto-continue function that waits until limit resets
-export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, shouldAttachLogs) => {
+// tempDir parameter is required for passing --working-directory to the resumed session
+// (Claude Code sessions are stored per-working-directory, so resume must use same directory)
+export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, shouldAttachLogs, tempDir = null) => {
   try {
     const resetTime = global.limitResetTime;
     const waitMs = calculateWaitTime(resetTime);
@@ -115,6 +117,17 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     if (argv.fork) resumeArgs.push('--fork');
     if (shouldAttachLogs) resumeArgs.push('--attach-logs');
 
+    // CRITICAL: Pass --working-directory to ensure Claude Code session resume works correctly
+    // Claude Code stores sessions per working directory, so resume MUST use the same directory
+    // Without this, resume creates a NEW temp directory and session is not found
+    if (tempDir) {
+      resumeArgs.push('--working-directory', tempDir);
+      await log(`📂 Using working directory for session continuity: ${tempDir}`);
+    } else {
+      await log(`⚠️  Warning: No working directory specified - session resume may fail`);
+      await log(`   Claude Code sessions are stored per-directory, consider using --working-directory`);
+    }
+
     await log(`\n🔄 Executing: ${resumeArgs.join(' ')}`);
 
     // Execute the resume command
@@ -136,7 +149,11 @@ export const autoContinueWhenLimitResets = async (issueUrl, sessionId, argv, sho
     });
     await log(`\n❌ Auto-continue failed: ${cleanErrorMessage(error)}`, { level: 'error' });
     await log('\n🔄 Manual resume command:');
-    await log(`./solve.mjs "${issueUrl}" --resume ${sessionId}`);
+    if (tempDir) {
+      await log(`./solve.mjs "${issueUrl}" --resume ${sessionId} --working-directory "${tempDir}"`);
+    } else {
+      await log(`./solve.mjs "${issueUrl}" --resume ${sessionId}`);
+    }
     await safeExit(1, 'Auto-continue failed');
   }
 };

package/src/solve.config.lib.mjs

@@ -47,6 +47,11 @@ export const createYargsConfig = yargsInstance => {
         description: 'Resume from a previous session ID (when limit was reached)',
         alias: 'r',
       })
+      .option('working-directory', {
+        type: 'string',
+        description: 'Use specified working directory instead of creating a new temp directory. If directory does not exist, it will be created and the repository will be cloned. Essential for --resume to work correctly with Claude Code sessions.',
+        alias: 'd',
+      })
       .option('only-prepare-command', {
         type: 'boolean',
         description: 'Only prepare and print the claude command without executing it',

package/src/solve.mjs

@@ -513,7 +513,7 @@ if (isPrUrl) {
 // Create or find temporary directory for cloning the repository
 // Pass workspace info for --enable-workspaces mode (works with all tools)
 const workspaceInfo = argv.enableWorkspaces ? { owner, repo, issueNumber } : null;
-const { tempDir, workspaceTmpDir } = await setupTempDirectory(argv, workspaceInfo);
+const { tempDir, workspaceTmpDir, needsClone } = await setupTempDirectory(argv, workspaceInfo);
 // Populate cleanup context for signal handlers
 cleanupContext.tempDir = tempDir;
 cleanupContext.argv = argv;
@@ -521,6 +521,7 @@ cleanupContext.argv = argv;
 let limitReached = false;
 try {
   // Set up repository and clone using the new module
+  // If --working-directory points to existing repo, needsClone is false and we skip cloning
   const { forkedRepo } = await setupRepositoryAndClone({
     argv,
     owner,
@@ -532,6 +533,7 @@ try {
     log,
     formatAligned,
     $,
+    needsClone,
   });
 
   // Verify default branch and status using the new module

package/src/solve.repo-setup.lib.mjs

@@ -3,14 +3,23 @@
  * Handles repository cloning, forking, and remote setup
  */
 
-export async function setupRepositoryAndClone({ argv, owner, repo, forkOwner, tempDir, isContinueMode, issueUrl, log, $ }) {
+export async function setupRepositoryAndClone({ argv, owner, repo, forkOwner, tempDir, isContinueMode, issueUrl, log, $, needsClone = true }) {
   // Set up repository and handle forking
   const { repoToClone, forkedRepo, upstreamRemote, prForkOwner } = await setupRepository(argv, owner, repo, forkOwner, issueUrl);
 
-  // Clone repository and set up remotes
-  await cloneRepository(repoToClone, tempDir, argv, owner, repo);
-  // Set up upstream remote and sync fork if needed
-  await setupUpstreamAndSync(tempDir, forkedRepo, upstreamRemote, owner, repo, argv);
+  // Clone repository and set up remotes (skip if needsClone is false - directory already has repo)
+  if (needsClone) {
+    await cloneRepository(repoToClone, tempDir, argv, owner, repo);
+    // Set up upstream remote and sync fork if needed
+    await setupUpstreamAndSync(tempDir, forkedRepo, upstreamRemote, owner, repo, argv);
+  } else {
+    await log('ℹ️  Skipping clone: Using existing repository in working directory');
+    // Still need to ensure upstream remote is set up if using fork mode
+    if (forkedRepo && upstreamRemote) {
+      await setupUpstreamAndSync(tempDir, forkedRepo, upstreamRemote, owner, repo, argv);
+    }
+  }
+
   // Set up pr-fork remote if we're continuing someone else's fork PR with --fork flag
   const prForkRemote = await setupPrForkRemote(tempDir, argv, prForkOwner, repo, isContinueMode, owner);
 

package/src/solve.repository.lib.mjs

@@ -220,16 +220,58 @@ export const buildWorkspacePath = (owner, repo, issueNumber, timestamp) => {
 // When --enable-workspaces is used, creates:
 //   {workspace}/repository - for the cloned repo
 //   {workspace}/tmp - for temp files, logs, downloads
+// When --working-directory is used, uses the specified directory (creates if needed)
 export const setupTempDirectory = async (argv, workspaceInfo = null) => {
   let tempDir;
   let workspaceTmpDir = null;
   let isResuming = argv.resume;
+  // needsClone indicates if the repository needs to be cloned into the directory
+  // This is true when: new directory is created, or existing directory is empty
+  let needsClone = true;
 
   // Check if workspace mode should be enabled (works with all tools)
   const useWorkspaces = argv.enableWorkspaces;
 
+  // Priority 1: --working-directory option takes precedence over all other directory selection
+  // This is essential for --resume to work correctly with Claude Code sessions,
+  // because Claude Code stores sessions by working directory path, not session ID alone
+  if (argv.workingDirectory) {
+    tempDir = path.resolve(argv.workingDirectory);
+
+    // Check if directory exists
+    try {
+      const stat = await fs.stat(tempDir);
+      if (stat.isDirectory()) {
+        // Directory exists - check if it contains a git repository
+        try {
+          await fs.access(path.join(tempDir, '.git'));
+          // Git repository exists - no need to clone
+          needsClone = false;
+          await log(`\n${formatAligned('📂', 'Working directory:', tempDir)}`);
+          await log(formatAligned('', 'Status:', 'Using existing repository', 2));
+          if (isResuming) {
+            await log(formatAligned('', 'Session:', `Resuming ${argv.resume}`, 2));
+          }
+        } catch {
+          // No .git directory - directory is empty or doesn't have a repo, will clone
+          await log(`\n${formatAligned('📂', 'Working directory:', tempDir)}`);
+          await log(formatAligned('', 'Status:', 'Directory exists but no repository - will clone', 2));
+        }
+      }
+    } catch {
+      // Directory doesn't exist - create it
+      await fs.mkdir(tempDir, { recursive: true });
+      await log(`\n${formatAligned('📂', 'Working directory:', tempDir)}`);
+      await log(formatAligned('', 'Status:', 'Created new directory - will clone repository', 2));
+    }
+
+    return { tempDir, workspaceTmpDir, isResuming, needsClone };
+  }
+
   if (isResuming) {
-    // When resuming, try to find existing directory or create a new one
+    // When resuming without --working-directory, create a new temp directory
+    // WARNING: This will NOT work correctly with Claude Code because the session
+    // is stored in a path-specific location. Use --working-directory for proper resume.
     const scriptDir = path.dirname(process.argv[1]);
     const sessionLogPattern = path.join(scriptDir, `${argv.resume}.log`);
 
@@ -241,7 +283,9 @@ export const setupTempDirectory = async (argv, workspaceInfo = null) => {
       // For resumed sessions, create new temp directory since old one may be cleaned up
       tempDir = path.join(os.tmpdir(), `gh-issue-solver-resume-${argv.resume}-${Date.now()}`);
       await fs.mkdir(tempDir, { recursive: true });
-      await log(`Creating new temporary directory for resumed session: ${tempDir}`);
+      await log(`⚠️  Creating new temporary directory for resumed session: ${tempDir}`);
+      await log(`   Note: Claude Code sessions are tied to working directory paths.`);
+      await log(`   If session resume fails, use --working-directory to specify the original directory.`);
     } catch (err) {
       reportError(err, {
         context: 'resume_session_lookup',
@@ -280,7 +324,7 @@ export const setupTempDirectory = async (argv, workspaceInfo = null) => {
     await log(`\nCreating temporary directory: ${tempDir}`);
   }
 
-  return { tempDir, workspaceTmpDir, isResuming };
+  return { tempDir, workspaceTmpDir, isResuming, needsClone };
 };
 
 // Try to initialize an empty repository by creating a simple README.md

package/src/solve.results.lib.mjs

@@ -377,7 +377,9 @@ export const showSessionSummary = async (sessionId, limitReached, argv, issueUrl
 
       if (argv.autoResumeOnLimitReset && global.limitResetTime) {
         await log(`\n🔄 AUTO-RESUME ON LIMIT RESET ENABLED - Will resume at ${global.limitResetTime}`);
-        await autoContinueWhenLimitResets(issueUrl, sessionId, argv, shouldAttachLogs);
+        // Pass tempDir to ensure resumed session uses the same working directory
+        // This is critical for Claude Code session resume to work correctly
+        await autoContinueWhenLimitResets(issueUrl, sessionId, argv, shouldAttachLogs, tempDir);
       } else {
         if (global.limitResetTime) {
           await log(`\n⏰ Limit resets at: ${global.limitResetTime}`);

package/src/telegram-bot.mjs

@@ -1069,18 +1069,32 @@ bot.command(/^solve$/i, async ctx => {
     return;
   }
 
+  // Use normalized URL from validation to ensure consistent duplicate detection
+  // See: https://github.com/link-assistant/hive-mind/issues/1080
+  const normalizedUrl = validation.parsed.normalized;
+
   const requester = buildUserMention({ user: ctx.from, parseMode: 'Markdown' });
   const optionsText = args.slice(1).join(' ') || 'none';
-  let infoBlock = `Requested by: ${requester}\nURL: ${escapeMarkdown(args[0])}\nOptions: ${optionsText}`;
+  let infoBlock = `Requested by: ${requester}\nURL: ${escapeMarkdown(normalizedUrl)}\nOptions: ${optionsText}`;
   if (solveOverrides.length > 0) infoBlock += `\n🔒 Locked options: ${solveOverrides.join(' ')}`;
   const solveQueue = getSolveQueue({ verbose: VERBOSE });
+
+  // Check for duplicate URL in queue
+  // See: https://github.com/link-assistant/hive-mind/issues/1080
+  const existingItem = solveQueue.findByUrl(normalizedUrl);
+  if (existingItem) {
+    const statusText = existingItem.status === 'starting' || existingItem.status === 'started' ? 'being processed' : 'already in the queue';
+    await ctx.reply(`❌ This URL is ${statusText}.\n\nURL: ${escapeMarkdown(normalizedUrl)}\nStatus: ${existingItem.status}\n\n💡 Use /solve-queue to check the queue status.`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
+    return;
+  }
+
   const check = await solveQueue.canStartCommand();
   const queueStats = solveQueue.getStats();
   if (check.canStart && queueStats.queued === 0) {
     const startingMessage = await ctx.reply(`🚀 Starting solve command...\n\n${infoBlock}`, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });
     await executeAndUpdateMessage(ctx, startingMessage, 'solve', args, infoBlock);
   } else {
-    const queueItem = solveQueue.enqueue({ url: args[0], args, ctx, requester, infoBlock, tool: solveTool });
+    const queueItem = solveQueue.enqueue({ url: normalizedUrl, args, ctx, requester, infoBlock, tool: solveTool });
     let queueMessage = `📋 Solve command queued (position #${queueStats.queued + 1})\n\n${infoBlock}`;
     if (check.reason) queueMessage += `\n\n⏳ Waiting: ${check.reason}`;
     const queuedMessage = await ctx.reply(queueMessage, { parse_mode: 'Markdown', reply_to_message_id: ctx.message.message_id });

package/src/telegram-solve-queue.lib.mjs

@@ -303,6 +303,30 @@ export class SolveQueue {
     return item;
   }
 
+  /**
+   * Find an item by URL in the queue or processing items
+   * Used to prevent duplicate URLs from being added to the queue
+   * @param {string} url - The URL to search for
+   * @returns {SolveQueueItem|null} The found item or null
+   * @see https://github.com/link-assistant/hive-mind/issues/1080
+   */
+  findByUrl(url) {
+    // Check queued items
+    const queuedItem = this.queue.find(item => item.url === url);
+    if (queuedItem) {
+      return queuedItem;
+    }
+
+    // Check processing items
+    for (const item of this.processing.values()) {
+      if (item.url === url) {
+        return item;
+      }
+    }
+
+    return null;
+  }
+
   /**
    * Cancel a queued item by ID
    * @param {string} id - Item ID