@thecolonylab/hivemind 0.1.3 → 0.2.1

package/dist/commands/coverage.js

@@ -6,6 +6,7 @@ import { checkCoverageLocally } from './coverageLocal.js';
 import { saveTestFile, slugify } from '../testFile/write.js';
 import { loadAllTestsFull } from '../testFile/loadAllTests.js';
 import { renderCoveragePrComment } from '../report/prComment.js';
+import { loadConfig } from '../config.js';
 /**
  * The actual diff-aware check: reads the real code diff (not just filenames), sends it — plus
  * every local test with its full steps — to the server. The server figures out which known
@@ -23,6 +24,7 @@ export async function coverageCommand(opts) {
     }
     const diff = getFullDiff(cwd, base);
     const localTests = await loadAllTestsFull(cwd);
+    const config = await loadConfig(cwd);
     const serverUrl = process.env.HIVEMIND_SERVER_URL || 'https://app.thecolonylab.com';
     console.log(`🐝 Scout reading the diff (${changedFiles.length} file${changedFiles.length === 1 ? '' : 's'} changed vs ${base})...`);
     if (opts.local) {
@@ -31,8 +33,8 @@ export async function coverageCommand(opts) {
     let result;
     try {
         result = opts.local
-            ? await checkCoverageLocally({ serverUrl, diff, localTests, headed: opts.headed })
-            : await coverageOnServer(diff, localTests);
+            ? await checkCoverageLocally({ serverUrl, diff, localTests, headed: opts.headed, projectId: config.projectId, projectName: config.projectName })
+            : await coverageOnServer(diff, localTests, config.projectId, config.projectName);
     }
     catch (err) {
         console.error(err.message);

package/dist/commands/coverageLocal.js

@@ -21,7 +21,7 @@ export async function checkCoverageLocally(opts) {
                 headers.Authorization = `Bearer ${apiKey}`;
             const socket = new WebSocket(wsUrl, { headers });
             socket.on('open', () => {
-                socket.send(JSON.stringify({ type: 'start', diff: opts.diff, localTests: opts.localTests }));
+                socket.send(JSON.stringify({ type: 'start', diff: opts.diff, localTests: opts.localTests, projectId: opts.projectId, projectName: opts.projectName }));
             });
             socket.on('message', async (raw) => {
                 let msg;

package/dist/commands/create.js

@@ -10,7 +10,7 @@ export async function createCommand(request, opts) {
     const accountLabels = Object.keys(config.accounts || {});
     let proposed;
     try {
-        proposed = await createOnServer(request, opts.url, existingTests, accountLabels);
+        proposed = await createOnServer(request, opts.url, existingTests, accountLabels, config.projectId);
     }
     catch (err) {
         console.error(err.message);

package/dist/commands/explore.js

@@ -2,6 +2,7 @@ import { join } from 'node:path';
 import { exploreOnServer } from '../serverClient.js';
 import { saveTestFile, slugify } from '../testFile/write.js';
 import { listExistingTests } from '../testFile/listExisting.js';
+import { loadConfig } from '../config.js';
 /**
  * A real multi-page crawl, not a one-shot snapshot — the server maps pages, follows doors, and
  * proposes starter tests along the way. Existing tests are sent along (same pattern `create`
@@ -9,10 +10,12 @@ import { listExistingTests } from '../testFile/listExisting.js';
  */
 export async function exploreCommand(url, opts) {
     console.log(`🐝 Scout dispatched to ${url}...`);
-    const existingTests = await listExistingTests(process.cwd());
+    const cwd = process.cwd();
+    const existingTests = await listExistingTests(cwd);
+    const config = await loadConfig(cwd);
     let proposed;
     try {
-        proposed = await exploreOnServer(url, existingTests);
+        proposed = await exploreOnServer(url, existingTests, config.projectId, config.projectName);
     }
     catch (err) {
         console.error(err.message);

package/dist/commands/init.js

@@ -1,8 +1,9 @@
 import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
+import { dirname, join, basename } from 'node:path';
 import { mkdir, readFile, writeFile, copyFile, access } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
+import { randomBytes } from 'node:crypto';
 const execFileAsync = promisify(execFile);
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // dist/commands/init.js -> package root (skill/ ships alongside dist/, see package.json "files")
@@ -70,16 +71,30 @@ export async function initCommand() {
     await ensureGitignore(cwd);
     const configPath = join(cwd, 'hivemind.config.json');
     if (await exists(configPath)) {
-        console.log('- hivemind.config.json already exists, left untouched');
+        // Patch in a projectId even for a config that predates this field — without it, every
+        // request to the server would look like it belongs to no project at all (or worse, get
+        // lumped in with other projects on the same account that also lack one).
+        const existing = JSON.parse(await readFile(configPath, 'utf-8'));
+        if (existing.projectId) {
+            console.log('- hivemind.config.json already exists, left untouched');
+        }
+        else {
+            existing.projectId = randomBytes(8).toString('hex');
+            existing.projectName ??= basename(cwd);
+            await writeFile(configPath, JSON.stringify(existing, null, 2) + '\n', 'utf-8');
+            console.log(`✓ hivemind.config.json — added a projectId (project name: "${existing.projectName}")`);
+        }
     }
     else {
         const starter = {
+            projectId: randomBytes(8).toString('hex'),
+            projectName: basename(cwd),
             environments: { default: 'http://localhost:3000' },
             accounts: {},
             areas: {},
         };
         await writeFile(configPath, JSON.stringify(starter, null, 2) + '\n', 'utf-8');
-        console.log('✓ hivemind.config.json created — edit environments.default to match your app');
+        console.log(`✓ hivemind.config.json created (project name: "${starter.projectName}") — edit environments.default to match your app`);
     }
     const agentsPath = join(cwd, 'AGENTS.md');
     const template = await readFile(join(packageRoot, 'skill', 'AGENTS.md.template'), 'utf-8');

package/dist/commands/run.js

@@ -115,6 +115,8 @@ export async function runCommand(target, opts) {
                     memoryContext,
                     credential,
                     headed: opts.headed,
+                    projectId: config.projectId,
+                    projectName: config.projectName,
                 });
                 await writeFile(join(cwd, 'hive', 'last-run.json'), JSON.stringify({ reportUrl: reportPath, name: test.name }, null, 2)).catch(() => { });
                 results[index] = { name: test.name, result, reportUrl: reportPath };
@@ -130,6 +132,8 @@ export async function runCommand(target, opts) {
                     steps: resolvedSteps,
                     memoryContext,
                     credential,
+                    projectId: config.projectId,
+                    projectName: config.projectName,
                 });
                 const reportUrl = `${serverUrl}${reportPath}`;
                 await writeLocalMemory(cwd, updatedMemory).catch(() => { });

package/dist/commands/runLocal.js

@@ -53,6 +53,8 @@ export async function runTestLocally(opts) {
                     url: opts.url,
                     steps: opts.steps,
                     memoryContext: opts.memoryContext,
+                    projectId: opts.projectId,
+                    projectName: opts.projectName,
                     credential: opts.credential,
                 }));
             });

package/dist/report/html.js

@@ -35,6 +35,17 @@ function renderTraceRow(l) {
       </span>
     </li>`;
 }
+function renderBrowserLogRow(b) {
+    const isBad = b.level === 'error' || b.level === 'failed' || Number(b.level) >= 400;
+    return `
+    <li class="trace-row ${isBad ? 'fail' : 'ok'}">
+      <span class="trace-status">${b.type === 'network' ? '⇄' : '»'}</span>
+      <span class="trace-body">
+        <span class="trace-tool">${escapeHtml(b.type)} · ${escapeHtml(b.level)}</span>
+        <span class="trace-reasoning">${escapeHtml(b.text)}</span>
+      </span>
+    </li>`;
+}
 export function renderHtmlReport(testName, result) {
     const passed = result.status === 'passed';
     const statusWord = passed ? 'PASS' : result.status === 'error' ? 'ERROR' : 'FAIL';
@@ -48,6 +59,7 @@ export function renderHtmlReport(testName, result) {
     const firstLabel = result.steps.find((s) => s.screenshot != null)?.text || result.screenshots[0]?.label || '';
     const stepsHtml = result.steps.map((s, i) => renderStepRow(s, i === 0)).join('\n');
     const traceHtml = result.toolLog.map(renderTraceRow).join('\n');
+    const browserLogHtml = result.browserLogs.map(renderBrowserLogRow).join('\n');
     const galleryHtml = result.screenshots
         .map((sc, i) => `<button class="thumb" data-shot="${i}" data-label="${escapeHtml(sc.label || '')}"><img src="${dataUris[i]}" loading="lazy" /></button>`)
         .join('\n');
@@ -226,6 +238,13 @@ export function renderHtmlReport(testName, result) {
   </details>`
         : ''}
 
+  ${result.browserLogs.length
+        ? `<details class="trace">
+    <summary>Console &amp; network (${result.browserLogs.length}) — errors and failed requests seen on the page during this run</summary>
+    <ul class="trace-list">${browserLogHtml}</ul>
+  </details>`
+        : ''}
+
   <script>
     const SHOTS = ${JSON.stringify(dataUris)};
     const LABELS = ${JSON.stringify(result.screenshots.map((s) => s.label || ''))};

package/dist/serverClient.js

@@ -29,14 +29,14 @@ async function post(path, body) {
 export async function runOnServer(input) {
     return post('/api/runs', input);
 }
-export async function createOnServer(request, url, existingTests, accountLabels) {
-    return post('/api/create', { request, url, existingTests, accountLabels });
+export async function createOnServer(request, url, existingTests, accountLabels, projectId) {
+    return post('/api/create', { request, url, existingTests, accountLabels, projectId });
 }
-export async function exploreOnServer(url, existingTests) {
-    return post('/api/explore', { url, existingTests });
+export async function exploreOnServer(url, existingTests, projectId, projectName) {
+    return post('/api/explore', { url, existingTests, projectId, projectName });
 }
-export async function coverageOnServer(diff, localTests) {
-    return post('/api/coverage', { diff, localTests });
+export async function coverageOnServer(diff, localTests, projectId, projectName) {
+    return post('/api/coverage', { diff, localTests, projectId, projectName });
 }
 export async function getDraftTest(code) {
     const apiKey = await readApiKey();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thecolonylab/hivemind",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Forager — the CLI that runs on your machine and executes for the Hivemind brain. Describe a flow in plain English, an AI agent drives a real browser and reports pass/fail. No LLM key needed on this machine.",
   "type": "module",
   "license": "MIT",