@mnemonik/shared 7.97.2 → 7.98.1

package/tests/projectIdentity.test.ts

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { parseIdentityFile, readIdentityFile } from '../src/projectIdentityFile.js';
+import { resolveProjectIdentity, resolveRepositoryRoot } from '../src/repositoryRoot.js';
+import { runIdentityFixtureSuite } from '../test-fixtures/identity/runner.mjs';
+
+runIdentityFixtureSuite(test, {
+  parse: parseIdentityFile,
+  read: readIdentityFile,
+  resolveRoot: resolveRepositoryRoot,
+  resolve: resolveProjectIdentity,
+});
+
+test('schema-v1 field type errors are malformed', () => {
+  const projectId = '11111111-1111-4111-8111-111111111111';
+  for (const value of [
+    { schemaVersion: 1, projectId: 42 },
+    { schemaVersion: 1, projectId, projectName: null },
+    { schemaVersion: 1, projectId, repositoryFingerprint: [] },
+    { schemaVersion: 1, projectId, repositoryFingerprint: { algorithmVersion: 2, hash: 'x' } },
+  ]) {
+    assert.equal(parseIdentityFile(JSON.stringify(value)).kind, 'malformed');
+  }
+});
+
+test('schema-v1 rejects unknown keys and names them', () => {
+  for (const value of [
+    {
+      schemaVersion: 1,
+      projectId: '11111111-1111-4111-8111-111111111111',
+      accessToken: 'Bearer secret',
+    },
+    {
+      schemaVersion: 1,
+      projectId: '11111111-1111-4111-8111-111111111111',
+      repositoryFingerprint: { algorithmVersion: 1, hash: 'x', secret: 'value' },
+    },
+  ]) {
+    const result = parseIdentityFile(JSON.stringify(value));
+    assert.equal(result.kind, 'malformed');
+    assert.match(result.detail, /accessToken|secret/);
+  }
+});
+
+test('schema-v1 requires canonical RFC 4122 UUID spelling', () => {
+  for (const projectId of [
+    '11111111-1111-1111-1111-111111111111',
+    '11111111-1111-4111-7111-111111111111',
+    'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa'.toUpperCase(),
+  ]) {
+    assert.equal(
+      parseIdentityFile(JSON.stringify({ schemaVersion: 1, projectId })).kind,
+      'malformed'
+    );
+  }
+});

package/tests/readiness.test.ts

@@ -0,0 +1,158 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  describeReadiness,
+  reduceReadiness,
+  serializeReadiness,
+  type ReadinessCondition,
+  type ReadinessState,
+} from '../src/readiness.js';
+
+const cases: Array<[ReadinessCondition, ReadinessState]> = [
+  [{ kind: 'selected_component_failed', reason: 'Scanner failed.' }, 'FAILED'],
+  [{ kind: 'host_trust_pending', reason: 'Approve Cursor.' }, 'ACTION_REQUIRED'],
+  [{ kind: 'vendor_policy_pending', reason: 'Allow the extension.' }, 'ACTION_REQUIRED'],
+  [{ kind: 'hooks_missing', reason: 'Hook declaration is missing.' }, 'ACTION_REQUIRED'],
+  [{ kind: 'host_not_connected', reason: 'Codex has not connected.' }, 'LIMITED'],
+  [{ kind: 'scanner_omitted', reason: 'Scanner was omitted.' }, 'LIMITED'],
+  [{ kind: 'project_uncovered', reason: 'Project is outside approved roots.' }, 'LIMITED'],
+  [{ kind: 'post_commit_upload_failed', reason: 'Result upload failed.' }, 'FAILED'],
+];
+
+test('fixed precedence chooses the worse state for every state pair', () => {
+  const rank: Record<ReadinessState, number> = {
+    READY: 0,
+    LIMITED: 1,
+    ACTION_REQUIRED: 2,
+    FAILED: 3,
+  };
+  assert.equal(reduceReadiness([]).state, 'READY');
+  for (const [left, leftState] of cases) {
+    assert.equal(reduceReadiness([left]).state, leftState);
+    for (const [right, rightState] of cases) {
+      const expected = rank[leftState] >= rank[rightState] ? leftState : rightState;
+      assert.equal(reduceReadiness([left, right]).state, expected);
+    }
+  }
+});
+
+test('special cases and indexing semantics stay fixed', () => {
+  assert.equal(
+    reduceReadiness([
+      { kind: 'scanner_omitted', reason: 'Limited Mode was acknowledged.' },
+      { kind: 'selected_component_failed', reason: 'Codex failed.' },
+    ]).state,
+    'FAILED'
+  );
+  assert.equal(
+    reduceReadiness([
+      { kind: 'scanner_omitted', reason: 'Limited Mode was acknowledged.' },
+      { kind: 'login_pending', reason: 'Sign in.' },
+    ]).state,
+    'ACTION_REQUIRED'
+  );
+  assert.deepEqual(
+    reduceReadiness([{ kind: 'windows_task_creation_failed', reason: 'Access denied.' }]),
+    {
+      state: 'LIMITED',
+      reasons: ['Access denied.'],
+      actions: ['Run mnemonik scanner enable to try again.'],
+    }
+  );
+  assert.equal(
+    reduceReadiness([{ kind: 'indexing_stalled', reason: 'No heartbeat in two minutes.' }]).state,
+    'FAILED'
+  );
+});
+
+test('serialization keeps progress separate and omits an unattempted project', () => {
+  const withProject = serializeReadiness({
+    installation: { conditions: [] },
+    projects: [
+      {
+        projectId: 'project-1',
+        summary: { conditions: [] },
+        indexing: { total: 3100, completed: 1240 },
+      },
+    ],
+    generatedAt: '2026-09-11T00:00:00.000Z',
+  });
+  assert.equal(withProject.projects?.[0]?.summary.state, 'READY');
+  assert.deepEqual(withProject.projects?.[0]?.indexing, { total: 3100, completed: 1240 });
+
+  const omitted = serializeReadiness({
+    installation: { conditions: [] },
+    generatedAt: '2026-09-11T00:00:00.000Z',
+  });
+  assert.equal(Object.hasOwn(omitted, 'projects'), false);
+  assert.equal(omitted.scanner, null);
+  assert.equal(omitted.devicesAndGrants, null);
+});
+
+test('the CLI sentence names the concrete reason and action', () => {
+  assert.equal(
+    describeReadiness(
+      reduceReadiness([
+        {
+          kind: 'host_skipped',
+          component: 'cursor',
+          reason: 'Cursor was skipped.',
+        },
+      ])
+    ),
+    'Done, with one thing left. Cursor was skipped. Connect it later: mnemonik connect cursor'
+  );
+});
+
+test('completion counts reasons requiring attention and preserves the development note', () => {
+  assert.equal(
+    describeReadiness({ state: 'LIMITED', reasons: ['dev_release_source'], actions: [] }),
+    'Done. dev_release_source.'
+  );
+  const reasons = Array.from({ length: 7 }, (_, index) => `problem_${index}`);
+  assert.equal(
+    describeReadiness({
+      state: 'LIMITED',
+      reasons: [...reasons, 'dev_release_source'],
+      actions: ['mnemonik repair'],
+    }),
+    `Done, with 7 things left. ${reasons.map((reason) => `${reason}.`).join(' ')} dev_release_source. mnemonik repair`
+  );
+  assert.equal(
+    describeReadiness({
+      state: 'LIMITED',
+      reasons: ['Scanner needs attention.'],
+      actions: ['First action.', 'Second action.'],
+    }),
+    'Done, with one thing left. Scanner needs attention. First action. Second action.'
+  );
+});
+
+test('optional version receipts round-trip while old schema-1 documents remain valid', async () => {
+  const { isReadinessDocument } = await import('../src/readiness.js');
+  const old = serializeReadiness({ installation: { conditions: [] } });
+  assert.equal(isReadinessDocument(old), true);
+  assert.equal(Object.hasOwn(old, 'versions'), false);
+  const versions = {
+    cli: '0.1.0',
+    scanner: '7.95.2',
+    hosts: [
+      { host: 'claude_code', editor: '2.1.0', hooks: '0.10.0' },
+      { host: 'codex', hooks: '0.9.0' },
+    ],
+  };
+  const current = serializeReadiness({ installation: { conditions: [] }, versions });
+  assert.deepEqual(current.versions, versions);
+  assert.equal(isReadinessDocument(current), true);
+  for (const invalid of [
+    null,
+    { cli: 12 },
+    { scanner: '' },
+    { cli: 'bad\nversion' },
+    { cli: 'x'.repeat(129) },
+    { hosts: [{ host: 'cursor', editor: true }] },
+    { hosts: [{ host: 'cursor', token: 'secret' }] },
+    { secret: 'no' },
+  ])
+    assert.equal(isReadinessDocument({ ...old, versions: invalid }), false);
+});

package/tests/repositoryFingerprint.test.ts

@@ -0,0 +1,26 @@
+import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { canonicalizeRemote, selectRemote } from '../src/repositoryFingerprint.js';
+
+const golden = JSON.parse(
+  readFileSync(new URL('./fixtures/repository-fingerprint-v1.golden.json', import.meta.url), 'utf8')
+);
+for (const row of golden.remotes) {
+  test(`${row.group}/${row.name}`, () =>
+    assert.deepEqual(canonicalizeRemote(row.url), row.expected));
+}
+for (const row of golden.selections) {
+  test(`selection/${row.name}`, () => assert.deepEqual(selectRemote(row.remotes), row.expected));
+}
+test('all golden hashes are SHA-256 of the exact canonical UTF-8', () => {
+  for (const row of [...golden.remotes, ...golden.selections]) {
+    const expected = row.expected.fingerprint ?? row.expected;
+    if (expected.canonical)
+      assert.equal(
+        expected.hash,
+        createHash('sha256').update(expected.canonical, 'utf8').digest('hex')
+      );
+  }
+});

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "noEmit": true
+  },
+  "include": ["src/**/*", "tests/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/wasm/bash.tags.scm

@@ -1,7 +1,7 @@
 ; Hand-written: tree-sitter-bash ships no queries/tags.scm.
 ;
 ; Node names verified by parsing a sample with the vendored bash.wasm rather than
-; taken from documentation — `function_definition` carries its name in a `name`
+; taken from documentation - `function_definition` carries its name in a `name`
 ; field typed `word`, covering both `foo() { }` and `function foo { }`.
 (function_definition
   name: (word) @name) @definition.function

package/wasm/groovy.tags.scm

@@ -2,7 +2,7 @@
 ;
 ; Node names verified against the vendored groovy.wasm. Groovy distinguishes a
 ; top-level `function_definition` from a `method_declaration` inside a
-; `class_body`, and both name via an `identifier` field — so methods get
+; `class_body`, and both name via an `identifier` field - so methods get
 ; definition.method and keep their own name, which is the defect this plan
 ; exists to fix for every language.
 (class_declaration

package/wasm/javascript.tags.scm

@@ -68,8 +68,8 @@
 ; ANCHORED TO `program` ON PURPOSE, and the anchor is load-bearing. The chunker's
 ; leaf rule only suppresses a definition nested inside ANOTHER DEFINITION; a bare
 ; block, an `if` body and a `for` initialiser are not definitions, so an
-; unanchored variable_declarator pattern writes locals — the `i` of every
-; for-loop, every `const` in every block — straight into
+; unanchored variable_declarator pattern writes locals - the `i` of every
+; for-loop, every `const` in every block - straight into
 ; `memory_file_index.symbol_name`, where the `symbol:` leg prefix-matches them.
 ; Measured on this repo, unanchored inflates the chunk count 28.9% and makes
 ; `symbol: i` return loop bodies. python.tags.scm anchors its constant pattern to

package/wasm/solidity.tags.scm

@@ -38,6 +38,6 @@
     ancestor: (user_defined_type (_) @name . )) @reference.class
 
 
-;; Imports ( note that unknown is not standardised )
+;; Imports (unknown is not standardised)
 (import_directive
   import_name: (_) @name ) @reference.unknown