@hamp10/agentforge 0.2.21 → 0.2.23

package/src/supervisor.js

@@ -10,7 +10,7 @@
  * worker code path is unchanged — only the lifecycle wrapper is new.
  */
 
-import { spawn } from 'child_process';
+import { spawn, execFileSync } from 'child_process';
 import { mkdirSync, writeFileSync, readFileSync, unlinkSync, existsSync } from 'fs';
 import { homedir } from 'os';
 import path from 'path';
@@ -32,25 +32,80 @@ function removePid(file) {
   try { unlinkSync(file); } catch {}
 }
 
+/**
+ * Kill a PID read from a file (if it exists and is still alive).
+ * Swallows errors — the process may already be gone.
+ */
+function killPidFile(file) {
+  try {
+    if (!existsSync(file)) return;
+    const pid = parseInt(readFileSync(file, 'utf8'));
+    if (pid && pid !== process.pid) {
+      try { process.kill(pid, 'SIGTERM'); } catch {}
+    }
+    removePid(file);
+  } catch {}
+}
+
+function killStaleAgentForgeProcesses() {
+  try {
+    const thisScript = process.argv[1] || '';
+    if (!thisScript) return;
+    const keep = new Set([process.pid, process.ppid].filter(Boolean).map(String));
+    const output = execFileSync('ps', ['-axo', 'pid=,ppid=,command='], { encoding: 'utf8' });
+    for (const rawLine of output.split('\n')) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      const match = line.match(/^(\d+)\s+(\d+)\s+(.+)$/);
+      if (!match) continue;
+      const [, pid, , command] = match;
+      if (keep.has(pid)) continue;
+      if (!command.includes(thisScript)) continue;
+      if (!/\bstart\b/.test(command)) continue;
+      try { process.kill(Number(pid), 'SIGTERM'); } catch {}
+    }
+  } catch {}
+}
+
+/**
+ * Check if there is already a supervisor running. Kill it (and its worker)
+ * before starting a new one so multiple agentforge start calls never stack up.
+ */
+function evictExistingWorker() {
+  killPidFile(WORKER_PID_FILE);
+  killPidFile(PID_FILE);
+  killStaleAgentForgeProcesses();
+}
+
 /**
  * Run the supervisor in the foreground. Blocks until a clean exit (code 0).
  * @param {string[]} innerArgv  argv to pass to the worker process (must include --no-daemon)
  */
 export async function runSupervisor(innerArgv) {
+  // Kill any already-running supervisor+worker before taking over.
+  // This prevents multiple workers from connecting when the user runs
+  // `agentforge start` more than once without stopping first.
+  evictExistingWorker();
+
   writePid(PID_FILE, process.pid);
 
-  // SIGTERM on supervisor = intentional stop (from agentforge stop command)
-  process.on('SIGTERM', () => {
-    console.log('[supervisor] Received SIGTERM — shutting down');
+  let currentChild = null;
+
+  const shutdown = (signal) => {
+    console.log(`[supervisor] Received ${signal} — shutting down`);
+    // Kill the worker child so it doesn't outlive the supervisor (macOS orphan issue)
+    if (currentChild && !currentChild.killed) {
+      try { currentChild.kill('SIGTERM'); } catch {}
+    }
+    removePid(WORKER_PID_FILE);
     removePid(PID_FILE);
     process.exit(0);
-  });
+  };
+
+  // SIGTERM on supervisor = intentional stop (from agentforge stop command)
+  process.on('SIGTERM', () => shutdown('SIGTERM'));
   // SIGINT = Ctrl+C in foreground terminal = intentional stop
-  process.on('SIGINT', () => {
-    console.log('[supervisor] Received SIGINT — shutting down');
-    removePid(PID_FILE);
-    process.exit(0);
-  });
+  process.on('SIGINT', () => shutdown('SIGINT'));
 
   let consecutiveCrashes = 0;
 
@@ -63,6 +118,7 @@ export async function runSupervisor(innerArgv) {
       env: { ...process.env, AGENTFORGE_SKIP_UPDATE: '1' },
     });
 
+    currentChild = child;
     writePid(WORKER_PID_FILE, child.pid);
 
     const exitCode = await new Promise(resolve => {
@@ -98,6 +154,9 @@ export async function runSupervisor(innerArgv) {
  * @param {string[]} supervisorArgv  argv for the background supervisor (without --detach)
  */
 export function detachSupervisor(supervisorArgv) {
+  // Kill any already-running supervisor+worker before starting a new one.
+  evictExistingWorker();
+
   const logFile = path.join(CONFIG_DIR, 'worker.log');
   mkdirSync(CONFIG_DIR, { recursive: true });
 
@@ -119,17 +178,26 @@ export function detachSupervisor(supervisorArgv) {
  * Stop a running background supervisor by sending SIGTERM to the PID in the pid file.
  */
 export function stopSupervisor() {
-  if (!existsSync(PID_FILE)) {
-    console.log('No running supervisor found.');
-    return;
+  let stopped = false;
+  // Kill worker first (so it doesn't get orphaned if supervisor dies first)
+  if (existsSync(WORKER_PID_FILE)) {
+    try {
+      const pid = parseInt(readFileSync(WORKER_PID_FILE, 'utf8'));
+      if (pid) { process.kill(pid, 'SIGTERM'); stopped = true; }
+    } catch {}
+    removePid(WORKER_PID_FILE);
   }
-  try {
-    const pid = parseInt(readFileSync(PID_FILE, 'utf8'));
-    process.kill(pid, 'SIGTERM');
-    removePid(PID_FILE);
-    console.log(`Stopped supervisor (PID ${pid})`);
-  } catch (e) {
-    console.log('Supervisor not running or already stopped.');
+  // Kill supervisor
+  if (existsSync(PID_FILE)) {
+    try {
+      const pid = parseInt(readFileSync(PID_FILE, 'utf8'));
+      if (pid) { process.kill(pid, 'SIGTERM'); stopped = true; }
+    } catch {}
     removePid(PID_FILE);
   }
+  if (stopped) {
+    console.log('✅ AgentForge worker stopped.');
+  } else {
+    console.log('No running worker found.');
+  }
 }

package/src/taskSemantics.js

@@ -0,0 +1,141 @@
+const PAGE_KIND_RE = /\b(?:pages?|screens?|routes?|views?|listings?)\b/i;
+const PAGE_KIND_WORD_RE = /^(?:listing|listings|page|pages|screen|screens|route|routes|view|views|site|website|app)$/i;
+const ACTION_WORD_RE = /^(?:add|build|change|create|edit|fix|implement|improve|make|redesign|update|work)$/i;
+
+const GENERIC_SCOPE_WORDS = new Set([
+  'a', 'an', 'the', 'and', 'or', 'page', 'pages', 'screen', 'screens',
+  'route', 'routes', 'view', 'views', 'listing', 'listings', 'site',
+  'website', 'app', 'readability', 'readable', 'legibility', 'contrast',
+  'quality', 'visual', 'content', 'layout', 'styling', 'polish',
+  'current', 'target', 'targets', 'requested', 'same', 'rest', 'live',
+  'local', 'itself', 'only', 'those', 'these', 'this', 'that', 'two',
+  'both', 'change', 'edit', 'modify', 'touch', 'make', 'improve', 'fix',
+  'update', 'redesign', 'owned', 'source', 'style', 'styles', 'global',
+  'shared', 'reference', 'references', 'broaden', 'work', 'wrong', 'bad',
+  'broken',
+]);
+
+const followedByNamedPageTargets = (text, match) => {
+  const after = text.slice(match.index + match[0].length);
+  return /^\s+(?:listing\s+)?(?:pages?|screens?|routes?|views?|listings?)\s+(?:for|of|called|named)\b/i.test(after);
+};
+
+export function scopeSlug(value) {
+  return String(value || '')
+    .toLowerCase()
+    .replace(/^https?:\/\//, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+export function scopeExtractionText(message) {
+  const raw = String(message || '');
+  const taskMatches = [...raw.matchAll(/\b(?:The task is|Continue with the task):\s*"([^"]{1,4000})"/gi)];
+  if (taskMatches.length > 0) {
+    const taskText = taskMatches.at(-1)[1];
+    const resolvedScopeBlocks = [...raw.matchAll(/\[Resolved (?:task|target) scope[^\]]*\]/gi)]
+      .map(match => match[0]);
+    return [taskText, ...resolvedScopeBlocks].join('\n');
+  }
+  return raw;
+}
+
+export function hasExplicitScopeRestriction(message) {
+  return /\b(do not (?:modify|change|edit|touch) anything else|don't (?:modify|change|edit|touch) anything else|only (?:touch|modify|change|edit|work on)|work only on|nothing else)\b/i.test(scopeExtractionText(message));
+}
+
+export function addScopeCandidate(candidates, value) {
+  const parts = String(value || '')
+    .replace(/\b(?:make|keep|commit|push|verify|test|do\s+not|don't|change|edit|modify|touch|improve|fix|update|redesign)\b[\s\S]*$/i, '')
+    .replace(/(.+?)\s+\b(?:the|a|an|this|that|these|those)\b(?=[\s\S]*\b(?:is|are|was|were|looks?|feels?|seems?|needs?|need|should|must|has|have)\b)[\s\S]*$/i, '$1')
+    .replace(/\s+\b(?:is|are|was|were|looks?|feels?|seems?|needs?|need|should|must|has|have)\b[\s\S]*$/i, '')
+    .split(/\s*(?:,|&|\band\b|\bor\b)\s*/i);
+
+  for (const part of parts) {
+    const cleaned = part
+      .replace(/(.+?)\s+\b(?:the|a|an|this|that|these|those)\b[\s\S]*$/i, '$1')
+      .replace(/\s+\b(?:is|are|was|were|looks?|feels?|seems?|needs?|need|should|must|has|have)\b[\s\S]*$/i, '')
+      .replace(/\b(?:a|an|the|page|pages|screen|screens|route|routes|view|views|listing|listings|site|website|app|readability|readable|legibility|contrast|quality|visual|content|layout|styling|polish|current|target|targets|requested|same|rest|live|local|itself|only|those|these|this|that|two|both|change|edit|modify|touch|make|improve|fix|update|redesign|owned|source|style|styles|global|shared|reference|references|broaden|work|off|wrong|bad|broken)\b/gi, ' ')
+      .trim();
+    const slug = scopeSlug(cleaned);
+    if (slug.length >= 3 && !GENERIC_SCOPE_WORDS.has(slug)) candidates.add(slug);
+  }
+}
+
+export function extractNamedPageScopeSlugs(message) {
+  const text = scopeExtractionText(message);
+  if (!PAGE_KIND_RE.test(text)) return [];
+
+  const candidates = new Set();
+  for (const match of text.matchAll(/\b[a-z0-9]+(?:[.-][a-z0-9]+)+\b/gi)) {
+    if (followedByNamedPageTargets(text, match)) continue;
+    addScopeCandidate(candidates, match[0]);
+  }
+
+  const beforePage = /\b(?:on|for|of|called|named)\s+(?:the\s+)?([a-z0-9][a-z0-9 _/-]{0,100}?)\s+(?:pages?|screens?|routes?|views?|listings?)\b/gi;
+  for (const match of text.matchAll(beforePage)) {
+    const after = text.slice(match.index + match[0].length);
+    if (/\blistings?\b/i.test(match[1]) && /^\s+(?:for|of)\b/i.test(after)) continue;
+    addScopeCandidate(candidates, match[1]);
+  }
+
+  const directBeforePage = /\b([a-z0-9][a-z0-9._/-]{2,80})\s+(?:pages?|screens?|routes?|views?|listings?)\b/gi;
+  for (const match of text.matchAll(directBeforePage)) {
+    addScopeCandidate(candidates, match[1]);
+  }
+
+  const afterPage = /\b(?:pages?|screens?|routes?|views?|listings?)\s+(?:for|of|called|named)\s+(?:the\s+)?([a-z0-9][a-z0-9 ._/-]{0,160}?)(?=$|[?!;]|\.(?:\s|$)|\s+(?:on|at|in|with|without|that|which|where|when|because|so|but)\b)/gi;
+  for (const match of text.matchAll(afterPage)) {
+    const before = text.slice(Math.max(0, match.index - 120), match.index);
+    const precedingToken = before.match(/\b([a-z0-9][a-z0-9._/-]{2,})\s*$/i)?.[1] || '';
+    if (precedingToken && !PAGE_KIND_WORD_RE.test(precedingToken) && !ACTION_WORD_RE.test(precedingToken)) {
+      continue;
+    }
+    addScopeCandidate(candidates, match[1]);
+  }
+
+  for (const match of text.matchAll(/\b[a-z0-9]+(?:[.-][a-z0-9]+)+\b/gi)) {
+    const after = text.slice(match.index + match[0].length);
+    const pageTarget = after.match(/^\s+(?:listing\s+)?(?:pages?|screens?|routes?|views?|listings?)\s+(?:for|of|called|named)\s+(?:the\s+)?([a-z0-9][a-z0-9 ._/-]{0,160}?)(?=$|[?!;]|\.(?:\s|$)|\s+(?:on|at|in|with|without|that|which|where|when|because|so|but)\b)/i);
+    if (pageTarget) {
+      const targetCandidates = new Set();
+      addScopeCandidate(targetCandidates, pageTarget[1]);
+      targetCandidates.delete(scopeSlug(match[0]));
+      if (targetCandidates.size === 0) continue;
+      candidates.delete(scopeSlug(match[0]));
+    }
+  }
+
+  return [...candidates];
+}
+
+export function extractExplicitScopeSlugs(message) {
+  const text = scopeExtractionText(message);
+  if (!hasExplicitScopeRestriction(text)) {
+    return extractNamedPageScopeSlugs(text);
+  }
+
+  const candidates = new Set();
+  for (const match of text.matchAll(/\b[a-z0-9]+(?:[.-][a-z0-9]+)+\b/gi)) {
+    if (followedByNamedPageTargets(text, match)) continue;
+    addScopeCandidate(candidates, match[0]);
+  }
+  for (const slug of extractNamedPageScopeSlugs(text)) {
+    candidates.add(slug);
+  }
+  return [...candidates];
+}
+
+export function extractExplicitScope(message) {
+  const text = scopeExtractionText(message);
+  const slugs = extractExplicitScopeSlugs(text);
+  const inferredNamedPageScope = !hasExplicitScopeRestriction(text) && slugs.length > 0;
+  const pageOnly =
+    slugs.length > 0 &&
+    (
+      inferredNamedPageScope ||
+      /\bonly\s+(?:touch|modify|change|edit|work on)\b[\s\S]{0,120}\b(?:pages?|screens?|routes?|views?)\b/i.test(text) ||
+      /\b(?:pages?|screens?|routes?|views?)\b[\s\S]{0,120}\bonly\b/i.test(text)
+    );
+  return { slugs, pageOnly };
+}