npm - @hamp10/agentforge - Versions diffs - 0.2.30 → 0.2.32 - Mend

@hamp10/agentforge 0.2.30 → 0.2.32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/package.json +1 -1
package/scripts/check-task-semantics.js +50 -2
package/src/OpenClawCLI.js +139 -5
package/src/worker.js +45 -1

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@hamp10/agentforge",
-  "version": "0.2.30",
+  "version": "0.2.32",
   "description": "AgentForge worker — connect your machine to agentforge.ai",
   "type": "module",
   "bin": {

package/scripts/check-task-semantics.js CHANGED Viewed

@@ -437,6 +437,15 @@ try {
   );
   rmSync(sharedCssFile, { force: true });
   writeFileSync(alphaFixturePath, alphaFixtureCurrent);
+  const wrongRouteDir = path.join(fixture.repo, 'public_html', 'alpha');
+  mkdirSync(wrongRouteDir, { recursive: true });
+  writeFileSync(path.join(wrongRouteDir, 'index.html'), '<!doctype html><html><body><h1>Alpha</h1></body></html>');
+  assert.match(
+    worker._formatScopeDriftNudge(worker._findScopeDriftRepoChanges(baseline, message)),
+    /public_html\/alpha\/index\.html/i,
+    'new same-scope route folders should be reported as out-of-scope when the project already has a page collection'
+  );
+  rmSync(wrongRouteDir, { recursive: true, force: true });
   const directOldHtml = '<!doctype html><html><body><main><section class="hero"><h1>Alpha</h1><p>Existing body copy.</p></section></main></body></html>';
   const directInlineStyleHtml = '<!doctype html><html><body><main><section class="hero" style="padding: 4rem; color: white;"><h1>Alpha</h1><p>Existing body copy.</p></section></main></body></html>';
   assert.throws(
@@ -552,9 +561,34 @@ try {
       fixture.repo,
       { task: 'Work on the listing page for Alpha. Only change that listing page.' }
     ),
-    /existing scoped page target/i,
+    /existing (?:scoped page target|page collection)/i,
     'scoped page work should not create a new same-slug page when an existing scoped target page is present'
   );
+  assert.throws(
+    () => cli._guardDirectFileWritePath(
+      path.join(fixture.repo, 'public_html', 'alpha', 'index.html'),
+      fixture.repo,
+      { task: message }
+    ),
+    /existing page collection/i,
+    'scoped page work should not create a route folder when the project has an existing page collection pattern'
+  );
+  const nestedDuplicateGamma = path.join(fixture.repo, path.basename(fixture.repo), 'public_html', 'domains', 'gamma.html');
+  mkdirSync(path.dirname(nestedDuplicateGamma), { recursive: true });
+  writeFileSync(nestedDuplicateGamma, '<!doctype html><html><body><h1>Gamma</h1></body></html>');
+  assert.doesNotThrow(
+    () => cli._guardDirectFileWritePath(
+      path.join(fixture.repo, 'public_html', 'domains', 'gamma.html'),
+      fixture.repo,
+      { task: 'Can you make listing pages for Gamma?' }
+    ),
+    'nested duplicate project copies should not block recreating the canonical page path'
+  );
+  assert.equal(
+    cli._directScopeFileCandidates(fixture.repo, ['gamma']).some(candidate => candidate.startsWith(`${path.basename(fixture.repo)}/`)),
+    false,
+    'scope candidates should not steer agents toward nested project-copy paths when the canonical parent exists'
+  );
   const extractedOldCss = Array.from({ length: 28 }, (_, i) =>
     `.hero-polish-${i} { color: #${String(100000 + i).slice(0, 6)}; padding: ${i + 1}px; margin: ${i}px; box-shadow: 0 0 ${i + 2}px rgba(0,0,0,.1); }`
   ).join('\n');
@@ -647,14 +681,28 @@ try {
     ),
     'scoped shell sed should ignore the substitution script and allow canonical target page edits'
   );
+  assert.throws(
+    () => cli._guardDirectBashCommand(
+      'touch public_html/css/domain-detail.css',
+      fixture.repo,
+      { task: message }
+    ),
+    /outside the requested task scope/i,
+    'direct scoped work should reject new generic CSS assets before the target page owns or links them'
+  );
+  writeFileSync(
+    alphaFixturePath,
+    alphaFixtureCurrent.replace('</head>', '<link rel="stylesheet" href="../css/domain-detail.css">\n</head>')
+  );
   assert.doesNotThrow(
     () => cli._guardDirectBashCommand(
       'touch public_html/css/domain-detail.css',
       fixture.repo,
       { task: message }
     ),
-    'direct scoped work should allow creating a new page-owned CSS asset before the target page links it'
+    'direct scoped work should allow generic CSS assets after they are linked only by scoped pages'
   );
+  writeFileSync(alphaFixturePath, alphaFixtureCurrent);
   const staleLinkedCssHtml = '<!doctype html><html><head><link rel="stylesheet" href="css/alpha.css"></head><body><main><section><h1>Alpha</h1><p>Fresh page body copy with rebuilt structure.</p></section></main></body></html>';
   assert.throws(
     () => cli._validateDirectUiFileContent(

package/src/OpenClawCLI.js CHANGED Viewed

@@ -617,12 +617,65 @@ export class OpenClawCLI extends EventEmitter {
     return /\.(?:html?|xhtml|astro|mdx?)$/i.test(String(relativePath || ''));
   }
-  _isDirectNewPageOwnedAssetPath(filePath, workDir, relativePath, pageOnly) {
+  _directFileMentionsAsset(content, sourceRel, assetRel) {
+    const source = String(content || '');
+    const assetUnix = String(assetRel || '').replace(/\\/g, '/');
+    const assetBase = path.basename(assetUnix);
+    const relativeFromSource = path.relative(path.dirname(sourceRel || ''), assetRel || '').replace(/\\/g, '/');
+    const candidates = [
+      assetBase,
+      assetUnix,
+      `/${assetUnix}`,
+      relativeFromSource,
+      relativeFromSource && !relativeFromSource.startsWith('.') ? `./${relativeFromSource}` : '',
+    ].filter(Boolean);
+    return candidates.some(candidate => source.includes(candidate));
+  }
+  _directCurrentPageSourceFiles(workDir) {
+    const names = new Set();
+    const addLines = (output) => {
+      for (const rel of String(output || '').split('\n').map(line => line.trim()).filter(Boolean)) {
+        if (this._isDirectPageSourcePath(rel)) names.add(rel);
+      }
+    };
+    try {
+      addLines(execFileSync('git', ['-C', workDir, 'ls-files'], {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }));
+      addLines(execFileSync('git', ['-C', workDir, 'ls-files', '--others', '--exclude-standard'], {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }));
+    } catch {}
+    return [...names].sort();
+  }
+  _isDirectNewPageOwnedAssetPath(filePath, workDir, relativePath, pageOnly, slugs = []) {
     if (!pageOnly || !this._isDirectPageAssetPath(relativePath)) return false;
-    if (existsSync(filePath)) return false;
     const relative = path.relative(workDir, filePath);
     if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) return false;
-    return true;
+    if (this._directScopeSlugsMatchingText(String(relativePath || '').toLowerCase(), slugs).length > 0) return true;
+    const sourceFiles = this._directCurrentPageSourceFiles(workDir).filter(file => file !== relativePath);
+    const scopedSources = [];
+    const outOfScopeMentions = [];
+    for (const sourceRel of sourceFiles) {
+      let content = '';
+      try {
+        content = readFileSync(path.join(workDir, sourceRel), 'utf-8');
+      } catch {
+        continue;
+      }
+      if (!this._directFileMentionsAsset(content, sourceRel, relativePath)) continue;
+      if (this._directScopeSlugsMatchingText(String(sourceRel || '').toLowerCase(), slugs).length > 0) {
+        scopedSources.push(sourceRel);
+      } else {
+        outOfScopeMentions.push(sourceRel);
+      }
+    }
+    return scopedSources.length > 0 && outOfScopeMentions.length === 0;
   }
   _isDirectScopedReferenceSourcePath(filePath, workDir, relativePath, slugs, pageOnly, task) {
@@ -659,11 +712,71 @@ export class OpenClawCLI extends EventEmitter {
     const slugAllowed = this._directScopeSlugsMatchingText(lower, slugs).length > 0;
     if (!slugAllowed) {
       if (this._isDirectScopedReferenceSourcePath(filePath, workDir, scopePath, slugs, pageOnly, task)) return true;
-      return this._isDirectNewPageOwnedAssetPath(filePath, workDir, scopePath, pageOnly);
+      return this._isDirectNewPageOwnedAssetPath(filePath, workDir, scopePath, pageOnly, slugs);
     }
     return !pageOnly || this._isDirectPageSourcePath(scopePath);
   }
+  _directHtmlPageCollectionDirs(workDir) {
+    if (!workDir) return [];
+    const counts = new Map();
+    try {
+      const output = execFileSync('git', ['-C', workDir, 'ls-files'], {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+      for (const rel of String(output || '').split('\n').map(line => line.trim()).filter(Boolean)) {
+        if (!this._isDirectHtmlPagePath(rel)) continue;
+        const absolute = path.resolve(workDir, rel);
+        if (this._nestedProjectCopyCanonicalPath(absolute, workDir)) continue;
+        const dir = path.dirname(rel);
+        if (!dir || dir === '.') continue;
+        counts.set(dir, (counts.get(dir) || 0) + 1);
+      }
+    } catch {
+      return [];
+    }
+    const dirs = [...counts.entries()]
+      .filter(([, count]) => count >= 2)
+      .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+      .map(([dir]) => dir);
+    return dirs.filter(dir => !dirs.some(other => other !== dir && this._directPathInsideRelDir(other, dir)));
+  }
+  _directPathInsideRelDir(relativePath, dir) {
+    const rel = path.relative(path.normalize(dir), path.normalize(relativePath));
+    return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
+  }
+  _directNewHtmlPageCollectionViolation(filePath, workDir, slugs, pageOnly, relativePath) {
+    if (!pageOnly || !Array.isArray(slugs) || slugs.length === 0) return null;
+    if (!this._isDirectHtmlPagePath(relativePath)) return null;
+    const lowerRelativePath = String(relativePath || '').toLowerCase();
+    const matchedSlugs = this._directScopeSlugsMatchingText(lowerRelativePath, slugs);
+    if (matchedSlugs.length === 0) return null;
+    if (this._gitTracksExactPath(workDir, relativePath)) return null;
+    const collectionDirs = this._directHtmlPageCollectionDirs(workDir);
+    if (collectionDirs.length === 0) return null;
+    if (collectionDirs.some(dir => this._directPathInsideRelDir(relativePath, dir))) return null;
+    const candidatePaths = [];
+    for (const dir of collectionDirs.slice(0, 4)) {
+      for (const slug of matchedSlugs) {
+        const aliases = new Set([slug]);
+        const withoutSuffix = slug.replace(/-(?:ai|app|co|com|dev|gg|io|net|org|so|xyz)$/i, '');
+        if (withoutSuffix && withoutSuffix !== slug && withoutSuffix.length >= 3) aliases.add(withoutSuffix);
+        for (const alias of aliases) candidatePaths.push(path.join(dir, `${alias}.html`));
+      }
+    }
+    return {
+      requested: relativePath,
+      collectionDirs,
+      candidatePaths: [...new Set(candidatePaths)].slice(0, 8),
+    };
+  }
 	  _directScopeFileCandidates(workDir, slugs, maxResults = 8) {
 	    if (!workDir || !Array.isArray(slugs) || slugs.length === 0) return [];
 	    const results = [];
@@ -694,7 +807,10 @@ export class OpenClawCLI extends EventEmitter {
 	    walk(workDir, 0);
 	    const resultSet = new Set(results);
 	    return results.filter(rel => {
-	      const canonical = this._nestedProjectDuplicateCanonicalPath(path.resolve(workDir, rel), workDir);
+        const absolute = path.resolve(workDir, rel);
+        const nestedCanonical = this._nestedProjectCopyCanonicalPath(absolute, workDir);
+        if (nestedCanonical && existsSync(path.dirname(nestedCanonical))) return false;
+	      const canonical = this._nestedProjectDuplicateCanonicalPath(absolute, workDir);
 	      if (!canonical) return true;
 	      const canonicalRel = path.relative(workDir, canonical) || canonical;
 	      return !resultSet.has(canonicalRel);
@@ -849,6 +965,24 @@ export class OpenClawCLI extends EventEmitter {
     if (!this._directTaskScopeAllowsPath(filePath, workDir, options.task)) {
       throw this._directScopeViolationError(this._formatDirectScopeError(filePath, workDir, options.task));
     }
+    const collectionViolation = this._directNewHtmlPageCollectionViolation(
+      filePath,
+      workDir,
+      slugs,
+      pageOnly,
+      relativePath
+    );
+    if (collectionViolation) {
+      throw this._directScopeViolationError([
+        'Refusing to create a new route/page path outside the project\'s existing page collection for this scoped page task.',
+        `Requested new page: ${collectionViolation.requested}`,
+        `Existing page collection director${collectionViolation.collectionDirs.length === 1 ? 'y' : 'ies'}: ${collectionViolation.collectionDirs.slice(0, 6).join(', ')}`,
+        collectionViolation.candidatePaths.length > 0
+          ? `Likely target path(s): ${collectionViolation.candidatePaths.join(', ')}`
+          : '',
+        'Use the project\'s existing page collection pattern instead of inventing a sibling URL or route folder.',
+      ].filter(Boolean).join(' '));
+    }
     if (pageOnly && slugs.length > 0 && this._isDirectHtmlPagePath(relativePath)) {
       const matchedSlugs = this._directScopeSlugsMatchingText(lowerRelativePath, slugs);
       const isTrackedTarget = this._gitTracksExactPath(workDir, relativePath);

package/src/worker.js CHANGED Viewed

@@ -646,6 +646,47 @@ export class AgentForgeWorker extends EventEmitter {
     return /\.(css|scss|sass|less|jsx?|tsx?)$/i.test(String(relativePath || ''));
   }
+  _isHtmlPagePath(relativePath) {
+    return /\.(?:html?|xhtml|astro|mdx?)$/i.test(String(relativePath || ''));
+  }
+  _htmlPageCollectionDirs(repo, ref = 'HEAD') {
+    if (!repo) return [];
+    const counts = new Map();
+    const output = this._gitOutput(repo, ['ls-tree', '-r', '--name-only', ref || 'HEAD'], 50000)
+      || this._gitOutput(repo, ['ls-files'], 50000);
+    for (const rel of String(output || '').split('\n').map(line => line.trim()).filter(Boolean)) {
+      if (!this._isHtmlPagePath(rel)) continue;
+      const parts = rel.split(/[\\/]+/).filter(Boolean);
+      if (parts.length >= 2 && parts[0].toLowerCase() === path.basename(repo).toLowerCase()) continue;
+      const dir = path.dirname(rel);
+      if (!dir || dir === '.') continue;
+      counts.set(dir, (counts.get(dir) || 0) + 1);
+    }
+    const dirs = [...counts.entries()]
+      .filter(([, count]) => count >= 2)
+      .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+      .map(([dir]) => dir);
+    return dirs.filter(dir => !dirs.some(other => other !== dir && this._pathInsideRelDir(other, dir)));
+  }
+  _pathInsideRelDir(relativePath, dir) {
+    const rel = path.relative(path.normalize(dir), path.normalize(relativePath));
+    return rel === '' || (!!rel && !rel.startsWith('..') && !path.isAbsolute(rel));
+  }
+  _isNewHtmlPageOutsideExistingCollection(baseline, rel, allowedSlugs, pageOnly) {
+    if (!baseline?.root || !pageOnly || !this._isHtmlPagePath(rel)) return false;
+    if (!Array.isArray(allowedSlugs) || allowedSlugs.length === 0) return false;
+    const lower = String(rel || '').toLowerCase();
+    if (this._scopeSlugsMatchingText(lower, allowedSlugs).length === 0) return false;
+    if (this._gitPathExistsAtRef(baseline.root, baseline.head || 'HEAD', rel)) return false;
+    const collectionDirs = this._htmlPageCollectionDirs(baseline.root, baseline.head || 'HEAD');
+    if (collectionDirs.length === 0) return false;
+    return !collectionDirs.some(dir => this._pathInsideRelDir(rel, dir));
+  }
   _fileMentionsAsset(content, sourceRel, assetRel) {
     const source = String(content || '');
     const assetUnix = String(assetRel || '').replace(/\\/g, '/');
@@ -723,7 +764,10 @@ export class AgentForgeWorker extends EventEmitter {
   _scopeAllowsChangedPath(baseline, rel, allowedSlugs, pageOnly, userMessage = '') {
     const lower = String(rel || '').toLowerCase();
     const slugAllowed = this._scopeSlugsMatchingText(lower, allowedSlugs).length > 0;
-    if (slugAllowed) return !pageOnly || this._isPageSourcePath(rel);
+    if (slugAllowed) {
+      if (this._isNewHtmlPageOutsideExistingCollection(baseline, rel, allowedSlugs, pageOnly)) return false;
+      return !pageOnly || this._isPageSourcePath(rel);
+    }
     if (this._isScopedReferenceSourcePath(baseline, rel, allowedSlugs, pageOnly, userMessage)) return true;
     return this._isNewScopedPageOwnedAsset(baseline, rel, allowedSlugs, pageOnly);
   }