simt-dev 0.1.1 → 0.2.1

package/src/resolve/eval.mjs

@@ -0,0 +1,64 @@
+// Gold-corpus evaluation: run each case through the resolver and score it.
+//
+// Plan 0002 section 9: "A resolver that is not measured is a resolver that is merely
+// felt." The corpus (test/fixtures/eval-corpus.json) states, for real repository signals
+// and tasks, which skills must come back and which must not. Two callers must never
+// disagree about the score - `simt skills eval` reports it to a reader, and
+// test/eval.test.mjs asserts it in CI - so the arithmetic lives here once (ADR-002).
+
+import { rankSkills, tokenize } from './resolve.mjs';
+
+/** The skill names the resolver selects for one case's declared signals and task. */
+function selectForCase(registry, c) {
+  const context = {
+    repoStack: c.repo?.stack ?? [],
+    paths: c.repo?.paths ?? [],
+    taskTokens: tokenize(c.task ?? ''),
+  };
+  const { selected } = rankSkills(registry.skills, context);
+  return selected.map((e) => e.skill.name);
+}
+
+/** Skill names the corpus cites that the registry does not declare. */
+export function unknownSkills(registry, corpus) {
+  const names = new Set(registry.skills.map((s) => s.name));
+  return [
+    ...new Set(
+      corpus.cases.flatMap((c) => [...(c.select ?? []), ...(c.reject ?? [])]).filter((n) => !names.has(n)),
+    ),
+  ];
+}
+
+/**
+ * Score the whole corpus: per-case detail plus precision and recall.
+ *
+ * `unexpected` is the half of precision that named negatives cannot see: a case whose
+ * truth is "nothing" names only a sample of what must not come back, so for those the
+ * whole selected set is the miss. `clean` is what the exit code rests on; the two
+ * ratios are measurements, and a case can break `clean` while both still read 1.0 -
+ * the first version of this arithmetic scored that case a perfect precision (S19).
+ */
+export function scoreCorpus(registry, corpus) {
+  let expected = 0;
+  let negatives = 0;
+  const cases = corpus.cases.map((c) => {
+    expected += c.select?.length ?? 0;
+    negatives += c.reject?.length ?? 0;
+    const got = new Set(selectForCase(registry, c));
+    const missing = (c.select ?? []).filter((n) => !got.has(n));
+    const wronglySelected = (c.reject ?? []).filter((n) => got.has(n));
+    return {
+      name: c.name,
+      selected: [...got],
+      missing,
+      wronglySelected,
+      unexpected: c.select?.length === 0 ? [...got] : wronglySelected,
+    };
+  });
+  const missed = cases.reduce((n, c) => n + c.missing.length, 0);
+  const wrong = cases.reduce((n, c) => n + c.wronglySelected.length, 0);
+  const recall = expected === 0 ? 1 : (expected - missed) / expected;
+  const precision = negatives === 0 ? 1 : (negatives - wrong) / negatives;
+  const clean = missed === 0 && cases.every((c) => c.unexpected.length === 0);
+  return { cases, expected, missed, negatives, wrong, recall, precision, clean };
+}

package/src/resolve/fingerprint.mjs

@@ -41,7 +41,7 @@ const MARKERS = [
 /**
  * Extensions are weaker evidence than marker files: a stray script must not
  * define a repo's stack. `python` is deliberately absent here because
- * simt-app carries .py tooling scripts inside a Gradle project - a marker file
+ * a repository carries .py tooling scripts inside a Gradle project - a marker file
  * is required for that tag. `kotlin` has no marker file, so it stays here.
  */
 const EXTENSION_TAGS = new Map([
@@ -83,7 +83,7 @@ const DEP_TAGS = new Map([
  *
  * Three, and the reason is a convention rather than a preference: the Android Gradle
  * Plugin puts a module's manifest at `<module>/src/main/AndroidManifest.xml`, and
- * simt-app's sits at `app/src/main/AndroidManifest.xml`. A bound shallower than the
+ * one common layout sits at `app/src/main/AndroidManifest.xml`. A bound shallower than the
  * convention makes `has-android-manifest` the shape S07 found - a fact no repository
  * could ever have. Deeper would be a scan rather than a probe, and ADR-013's promise
  * is that adding an ecosystem is data, so a fact must not cost a search.
@@ -178,6 +178,7 @@ const FACTS = [
   { name: 'has-pubspec', kind: 'file', paths: ['pubspec.yaml'] },
   { name: 'has-swift-package', kind: 'file', paths: ['Package.swift'] },
   { name: 'has-mix', kind: 'file', paths: ['mix.exs'] },
+  { name: 'has-deno-config', kind: 'file', paths: ['deno.json', 'deno.jsonc'] },
   { name: 'has-bun-lock', kind: 'file', paths: ['bun.lock', 'bun.lockb'] },
   // A glob walk skips dot directories, and `.devcontainer` is one. Stat the path.
   { name: 'has-devcontainer', kind: 'path', paths: ['.devcontainer/devcontainer.json'] },
@@ -300,7 +301,7 @@ export async function fingerprint(root) {
     }
   }
 
-  // simt-app and wakt-app both carry a wear/ module; wakt-app is the wearable.
+  // two repositories both carry a wear/ module; only one of them is the wearable.
   if (names.has('wear') && (await isDir(join(root, 'wear')))) {
     stack.add('wear-os');
     evidence.push('wear/');

package/src/resolve/near.mjs

@@ -10,7 +10,7 @@
 // suggestion that far away is noise: an agent will install the wrong skill.
 
 /** Levenshtein distance, two-row, with an early exit once the bound is passed. */
-export function editDistance(a, b, max = Infinity) {
+function editDistance(a, b, max = Infinity) {
   if (a === b) return 0;
   if (Math.abs(a.length - b.length) > max) return max + 1;
 
@@ -38,22 +38,41 @@ export function editDistance(a, b, max = Infinity) {
 /**
  * Candidates worth suggesting, nearest first.
  *
- * A substring hit is always included: `skill` is a real answer for a query of
- * `slice-commit`, and the distance test alone would rank it below noise.
+ * Two directions of substring, and they are not the same claim about what was typed.
+ *
+ * **The candidate contains the query** — `slice-commit` for `slice-commmit` — is a
+ * hit: the agent typed a prefix. It scores 1, not 0, because zero edits is what an
+ * exact match means and a prefix is not one. Scoring both 0 sorted `graph` ahead of
+ * `graphs` for the query `graphs`, and an agent that installs the first name in a
+ * "did you mean" list installs the wrong one.
+ *
+ * **The candidate sits inside the query** — `coverage` for `coverage-hunt` — is a hit
+ * only when it is at least half the query. Without that, the rule degenerates: `e` is
+ * a substring of `test`, so `nearMatches('test', ['e'])` returned `e` at distance 0
+ * and the message read `did you mean e?`.
+ *
+ * The bound also shrinks with the query, which is the same failure from the other side.
+ * Three edits is a typo in a name; three edits to a four-character query is a
+ * different string, and offering it violates the rule in the header of this file — "a
+ * suggestion that far away is noise: an agent will install the wrong skill". Under
+ * three characters nothing is a typo, so nothing is offered.
  */
 export function nearMatches(needle, candidates, { max = 3, limit = 3 } = {}) {
   if (!needle) return [];
   const lower = needle.toLowerCase();
+  const bound = Math.max(1, Math.min(max, Math.floor(lower.length / 3)));
 
   const scored = [];
   for (const candidate of candidates) {
     const cl = candidate.toLowerCase();
-    if (cl.includes(lower) || lower.includes(cl)) {
+    if (cl === lower) {
       scored.push({ candidate, distance: 0 });
-      continue;
+    } else if (cl.includes(lower) || (lower.includes(cl) && cl.length * 2 >= lower.length)) {
+      scored.push({ candidate, distance: 1 });
+    } else {
+      const distance = editDistance(lower, cl, bound);
+      if (distance <= bound) scored.push({ candidate, distance });
     }
-    const distance = editDistance(lower, cl, max);
-    if (distance <= max) scored.push({ candidate, distance });
   }
 
   scored.sort((a, b) => a.distance - b.distance || a.candidate.localeCompare(b.candidate));

package/src/resolve/resolve.mjs

@@ -210,7 +210,7 @@ export function stackCompatible(skill, repoSignals) {
  * agent knows it is standing in that repo, so name the overlapping tag when there
  * is one and say plainly when there is not.
  */
-export function stackReason(skill, repoSignals) {
+function stackReason(skill, repoSignals) {
   if (repoSignals.length === 0) return 'repo signals undetected, not excluded';
   const repo = new Set(repoSignals);
   const overlap = (skill.stack ?? []).filter((tag) => repo.has(tag));

package/src/resolve/source.mjs

@@ -8,7 +8,7 @@
 //
 // The second location is the one nobody wrote down: **the repository being operated
 // on is itself a location for a declared source**. Someone who cloned only
-// `simt-social` has the `simt-social` body on disk at `.agents/skills/slice-commit`
+// one repository has its body on disk at `.agents/skills/slice-commit`
 // with no workspace anywhere. The registry entry is satisfied by that file.
 //
 // Bytes are what make this safe rather than hopeful. Every source declares its size,
@@ -35,7 +35,7 @@ import { measureSkill } from '../graph/load.mjs';
  *
  * @returns {{path: string, how: 'workspace'|'repo'}[]}
  */
-export function candidateLocations(source, { workspaceRoot = null, root = null } = {}) {
+function candidateLocations(source, { workspaceRoot = null, root = null } = {}) {
   const out = [];
   if (workspaceRoot) out.push({ path: join(workspaceRoot, source.repo, source.path), how: 'workspace' });
   if (root) out.push({ path: join(root, source.path), how: 'repo' });

package/src/tsconfig.mjs

@@ -32,7 +32,7 @@ export const TSCONFIG_FILE = 'tsconfig.json';
  * The strictness floor.
  *
  * Every key here is already set, and set the same way, by every `tsconfig.json` in the
- * estate that could afford it. `simt-goto` is the outlier and it is not one on purpose: it
+ * estate that could afford it. One repository is the outlier and it is not one on purpose: it
  * is missing the seven flags below that the three social repos share, which is the gap
  * plan section 3.1 row 5 named. Nothing in this object is a value anybody has argued about;
  * it is the intersection of what four repositories independently wrote.

package/src/workspace.mjs

@@ -252,15 +252,6 @@ function absolute(p) {
   return isAbsolute(expanded) ? expanded : resolve(expanded);
 }
 
-/**
- * The workspace, or null. Callers that can degrade use this and report `source: 'none'`;
- * callers that genuinely cannot proceed should use `resolveWorkspace` and fail with its detail.
- */
-export async function workspaceOrNull(flags = {}, options = {}) {
-  const { root, error } = await resolveWorkspace(flags, options);
-  return error ? null : root;
-}
-
 /**
  * The path a multi-repo command should work on: `--root` or the first positional if
  * given, else the resolved workspace, else the current directory.