happyskills 1.13.0 → 1.14.0

package/src/utils/concurrency.test.js

@@ -0,0 +1,53 @@
+'use strict'
+// Spec 260629-03 §4.5 — bounded() over core-async throttle. The three load-
+// bearing guarantees: never exceed the limit, complete every task in order, and
+// a throwing task yields `{ error }` WITHOUT rejecting the whole batch (so one
+// bad skill never aborts a match scan). Run with: node --test.
+
+const { test } = require('node:test')
+const assert = require('node:assert/strict')
+const { bounded, DEFAULT_CONCURRENCY } = require('./concurrency')
+
+test('never exceeds the limit, completes every task, preserves order', async () => {
+	let inflight = 0, peak = 0
+	const mk = (i) => async () => {
+		inflight++; peak = Math.max(peak, inflight)
+		await new Promise(r => setTimeout(r, 5))
+		inflight--
+		return i
+	}
+	const tasks = Array.from({ length: 20 }, (_, i) => mk(i))
+	const res = await bounded(tasks, 4)
+	assert.ok(peak <= 4, `peak concurrency ${peak} must not exceed the limit of 4`)
+	assert.deepEqual(res, Array.from({ length: 20 }, (_, i) => i), 'all tasks complete, order preserved')
+})
+
+test('a throwing task yields { error } without rejecting the batch', async () => {
+	const tasks = [
+		async () => 'ok-0',
+		async () => { throw new Error('boom-1') },
+		async () => 'ok-2',
+	]
+	const res = await bounded(tasks, 2)
+	assert.equal(res[0], 'ok-0')
+	assert.ok(res[1] && res[1].error instanceof Error, 'failed task is partitioned as { error }')
+	assert.match(res[1].error.message, /boom-1/)
+	assert.equal(res[2], 'ok-2', 'sibling tasks still complete')
+})
+
+test('defaults to DEFAULT_CONCURRENCY and tolerates a bad limit', async () => {
+	assert.equal(DEFAULT_CONCURRENCY, 6)
+	let inflight = 0, peak = 0
+	const mk = () => async () => {
+		inflight++; peak = Math.max(peak, inflight)
+		await new Promise(r => setTimeout(r, 5))
+		inflight--
+	}
+	await bounded(Array.from({ length: 12 }, mk), 0) // 0 is invalid → falls back to the default
+	assert.ok(peak <= DEFAULT_CONCURRENCY, `bad limit must fall back to ${DEFAULT_CONCURRENCY}, peak was ${peak}`)
+})
+
+test('empty / non-array input resolves to an empty array', async () => {
+	assert.deepEqual(await bounded([], 4), [])
+	assert.deepEqual(await bounded(undefined, 4), [])
+})

package/src/utils/git_hash.js

@@ -6,4 +6,32 @@ const hash_blob = (buf) => {
 	return crypto.createHash('sha256').update(header).update(buf).digest('hex')
 }
 
-module.exports = { hash_blob }
+// Git-tree hash over a flat entry list — an EXACT byte-for-byte mirror of the
+// server's canonical `hash_tree` in api/app/utils/git_objects.js. The server
+// builds the tree from the flat file list the CLI pushes, so the CLI never had
+// a tree hash of its own; `happyskills match` needs one to reproduce a skill's
+// catalog `tree_sha` locally and compare it (spec 260629-03 §4.6). Identity:
+// equal tree_sha ⇒ byte-identical skill. Cross-package import is impossible
+// (separate npm packages), so this is a deliberate mirror — if the server
+// algorithm ever changes, change it here too (the e2e journey
+// match-local-skills.spec.js proves the two stay byte-aligned end-to-end).
+//
+// Entries: [{ path, sha }] (sha = the file's blob hash). Sorted by
+// path.localeCompare, serialized as `<mode> <path>\0<32-byte-binary-sha>`,
+// wrapped in `tree <len>\0`, then sha256'd. mode defaults to '100644' (the
+// server never sends a mode either).
+const hash_tree = (entries) => {
+	const sorted = [...entries].sort((a, b) => a.path.localeCompare(b.path))
+	const parts = sorted.map(entry => {
+		const mode = entry.mode || '100644'
+		const prefix = Buffer.from(`${mode} ${entry.path}\0`)
+		const sha_bin = Buffer.from(entry.sha, 'hex')
+		return Buffer.concat([prefix, sha_bin])
+	})
+	const content = Buffer.concat(parts)
+	const header = Buffer.from(`tree ${content.length}\0`)
+	const full = Buffer.concat([header, content])
+	return crypto.createHash('sha256').update(full).digest('hex')
+}
+
+module.exports = { hash_blob, hash_tree }