@neocompose/cli 0.25.1 → 0.25.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.25.2] - 2026-08-09
+
+### Added
+
+- `neo doctor` now audits the pulled document itself, not just this working
+  copy's authoring contracts. A project can be perfectly clean to push and
+  still hold malformed records, and the first audit catches value rows whose
+  storage partition disagrees with their placement parent. `--json` carries a
+  `repair` entry per finding, which is what lets the matching repair touch only
+  the affected records instead of scanning a project to rediscover them.
+
 ## [0.25.1] - 2026-08-09
 
 ### Changed

package/dist/neo.mjs

@@ -96381,6 +96381,181 @@ var init_scaffold = __esm({
   }
 });
 
+// src/project-source/project-integrity.ts
+function auditProjectIntegrity(workspace) {
+  const records2 = workspace.state.records;
+  const values = collectValueRows(records2);
+  const placements = collectPlacements(values);
+  const memberIdBySchemaKey = collectClassSchemas(records2);
+  const storageKeyByMemberId = collectMemberStorageKeys(records2);
+  const findings = [];
+  for (const value of values.values()) {
+    const placement = placements.get(value.id);
+    if (placement === void 0) continue;
+    const declaration = childStorageKeyDeclaration({
+      placement,
+      memberIdBySchemaKey,
+      storageKeyByMemberId
+    });
+    if (declaration === null) continue;
+    const expected = resolveMapKeyForCreatedValue({
+      declaration,
+      parentMapKey: placement.parent.mapKey,
+      parentClassId: placement.parent.classId ?? void 0
+    });
+    const normalizedExpected = normalizePartition(expected);
+    const normalizedActual = normalizePartition(value.mapKey);
+    if (normalizedExpected === normalizedActual) continue;
+    findings.push({
+      kind: "value-storage-partition",
+      recordKind: "value",
+      recordId: value.id,
+      message: `Value "${value.id}" is stored in partition ${describePartition(normalizedActual)} but its placement parent "${placement.parent.id}" puts it in ${describePartition(normalizedExpected)}.`,
+      repair: {
+        valueId: value.id,
+        parentValueId: placement.parent.id,
+        schemaKey: placement.schemaKey,
+        actualMapKey: normalizedActual,
+        expectedMapKey: normalizedExpected
+      }
+    });
+  }
+  return findings.sort(
+    (left, right) => left.recordId.localeCompare(right.recordId)
+  );
+}
+function childStorageKeyDeclaration(args) {
+  const { placement } = args;
+  if (placement.schemaKey === UNORDERED_MEMBERSHIP_KEY) {
+    return normalizeStorageKeyDeclaration(void 0);
+  }
+  const parentClassId = placement.parent.classId;
+  if (parentClassId === null) return null;
+  const memberId = args.memberIdBySchemaKey.get(parentClassId)?.get(placement.schemaKey);
+  if (memberId === void 0) return null;
+  const declaration = args.storageKeyByMemberId.get(memberId);
+  if (declaration === void 0) return null;
+  return declaration;
+}
+function collectValueRows(records2) {
+  const values = /* @__PURE__ */ new Map();
+  for (const record3 of Object.values(records2)) {
+    if (record3.recordKind !== "value") continue;
+    const data = record3.data;
+    if (!isObjectRecord2(data)) continue;
+    values.set(record3.recordId, {
+      id: record3.recordId,
+      classId: typeof data.classId === "string" ? data.classId : null,
+      mapKey: typeof data.mapKey === "string" ? data.mapKey : null,
+      containerId: typeof data.containerId === "string" ? data.containerId : null,
+      value: data.value
+    });
+  }
+  return values;
+}
+function collectPlacements(values) {
+  const placements = /* @__PURE__ */ new Map();
+  const claim = (childId, placement) => {
+    if (values.has(childId) && !placements.has(childId)) {
+      placements.set(childId, placement);
+    }
+  };
+  for (const parent of values.values()) {
+    const body = parent.value;
+    if (isObjectRecord2(body)) {
+      for (const [schemaKey, childId] of Object.entries(body)) {
+        if (typeof childId === "string") claim(childId, { parent, schemaKey });
+      }
+      continue;
+    }
+    if (!Array.isArray(body)) continue;
+    for (const childId of body) {
+      if (typeof childId === "string") {
+        claim(childId, { parent, schemaKey: UNORDERED_MEMBERSHIP_KEY });
+      }
+    }
+  }
+  for (const value of values.values()) {
+    if (value.containerId === null) continue;
+    const container = values.get(value.containerId);
+    if (container === void 0) continue;
+    claim(value.id, { parent: container, schemaKey: UNORDERED_MEMBERSHIP_KEY });
+  }
+  return placements;
+}
+function collectClassSchemas(records2) {
+  const schemas = /* @__PURE__ */ new Map();
+  for (const record3 of Object.values(records2)) {
+    if (record3.recordKind !== "class") continue;
+    const data = record3.data;
+    if (!isObjectRecord2(data) || !isObjectRecord2(data.schema)) continue;
+    const schema = /* @__PURE__ */ new Map();
+    for (const [schemaKey, memberId] of Object.entries(data.schema)) {
+      if (typeof memberId === "string") schema.set(schemaKey, memberId);
+    }
+    schemas.set(record3.recordId, schema);
+  }
+  for (const record3 of Object.values(records2)) {
+    if (record3.recordKind !== "class") continue;
+    const own = schemas.get(record3.recordId);
+    if (own === void 0) continue;
+    const seen = /* @__PURE__ */ new Set([record3.recordId]);
+    let data = record3.data;
+    while (isObjectRecord2(data) && typeof data.extendsClassId === "string") {
+      const parentId = data.extendsClassId;
+      if (seen.has(parentId)) break;
+      seen.add(parentId);
+      for (const [schemaKey, memberId] of schemas.get(parentId) ?? []) {
+        if (!own.has(schemaKey)) own.set(schemaKey, memberId);
+      }
+      const parentRecord = records2[`class:${parentId}`];
+      data = parentRecord?.data;
+    }
+  }
+  return schemas;
+}
+function collectMemberStorageKeys(records2) {
+  const declarations = /* @__PURE__ */ new Map();
+  for (const record3 of Object.values(records2)) {
+    if (record3.recordKind !== "member") continue;
+    let data = record3.data;
+    const seen = /* @__PURE__ */ new Set([record3.recordId]);
+    let declaration;
+    while (isObjectRecord2(data)) {
+      if (typeof data.storageKey === "string" && data.storageKey.length > 0) {
+        declaration = data.storageKey;
+        break;
+      }
+      if (typeof data.extendsMemberId !== "string") break;
+      const parentId = data.extendsMemberId;
+      if (seen.has(parentId)) break;
+      seen.add(parentId);
+      data = records2[`member:${parentId}`]?.data;
+    }
+    declarations.set(
+      record3.recordId,
+      normalizeStorageKeyDeclaration(declaration)
+    );
+  }
+  return declarations;
+}
+function normalizePartition(mapKey) {
+  if (mapKey === null || mapKey.length === 0) return null;
+  return mapKey === MAIN_STORAGE_PARTITION ? null : mapKey;
+}
+function describePartition(mapKey) {
+  return mapKey === null ? `"${MAIN_STORAGE_PARTITION}"` : `"${mapKey}"`;
+}
+var UNORDERED_MEMBERSHIP_KEY;
+var init_project_integrity = __esm({
+  "src/project-source/project-integrity.ts"() {
+    "use strict";
+    init_member_storage_key();
+    init_projection();
+    UNORDERED_MEMBERSHIP_KEY = "(container)";
+  }
+});
+
 // src/neoscript-language-adapter.ts
 function createCliNeoScriptContext(options) {
   const members = [...options.documents.members];
@@ -103262,7 +103437,7 @@ var init_registry2 = __esm({
     PROJECT_SCHEMA_CONTRACT = Object.freeze({
       formatVersion: 3,
       contractVersion: "3.9",
-      cliVersion: "0.25.1",
+      cliVersion: "0.25.2",
       projectFileUploadBatchSize: 32,
       documentRecords: {
         member: {
@@ -106044,8 +106219,10 @@ function inspectNeoDoctor(workspace) {
     errors: [],
     compatible: true
   };
+  const findings = auditProjectIntegrity(workspace);
   return {
     ok: formatCompatible && compiler.compatible && extension.compatible && source.compatible && files.compatible,
+    document: { findings, consistent: findings.length === 0 },
     format: {
       current: workspace.config.formatVersion,
       expected: CURRENT_FORMAT_VERSION,
@@ -106304,6 +106481,12 @@ async function runDoctor(workspace, json) {
   console.log(
     `  Files: contract v${String(report.files.contractVersion)}, SHA-256, ${String(report.files.trackedBinaryCount)} tracked binar${report.files.trackedBinaryCount === 1 ? "y" : "ies"}, workspace ${report.files.workspaceReadable ? "readable" : "not readable"}/${report.files.workspaceWritable ? "writable" : "not writable"}`
   );
+  console.log(
+    `  Document: ${report.document.consistent ? "no malformed records" : `${String(report.document.findings.length)} malformed record${report.document.findings.length === 1 ? "" : "s"} (from the last pull)`}`
+  );
+  for (const finding of report.document.findings) {
+    console.log(`  Document defect (${finding.kind}): ${finding.message}`);
+  }
   if (report.compiler.error)
     console.log(`  Compiler error: ${report.compiler.error}`);
   if (report.extension.error)
@@ -106315,6 +106498,11 @@ async function runDoctor(workspace, json) {
   console.log(
     report.ok ? "Project authoring contracts are compatible." : "Project authoring contracts need attention."
   );
+  if (!report.document.consistent) {
+    console.log(
+      `${String(report.document.findings.length)} malformed record${report.document.findings.length === 1 ? "" : "s"} in the pulled document \u2014 see \`--json\` for the repair entries.`
+    );
+  }
   if (!report.ok) process.exitCode = 1;
 }
 var NEO_COMPILER_CONTRACT, NEO_VSCODE_EXTENSION_ID, NEO_VSCODE_EXTENSION_CONTRACT_VERSION, NEO_SOURCE_CONTRACT_VERSION, NEO_FILE_CONTRACT_VERSION, SOURCE_EXTENSIONS, FILE_CAPABILITIES;
@@ -106326,6 +106514,7 @@ var init_doctor = __esm({
     init_workspace_status();
     init_source_diagnostics();
     init_project_documents();
+    init_project_integrity();
     NEO_COMPILER_CONTRACT = "ProjectSourceAnalysisV4";
     NEO_VSCODE_EXTENSION_ID = "neocompose.neo-compose-neoscript";
     NEO_VSCODE_EXTENSION_CONTRACT_VERSION = "0.3.0";
@@ -109302,7 +109491,7 @@ ${h("Working copy")}
   test      ${d("[file-or-dir ...] [-t <pattern>] [--reporter=json] [--outputFile <path>]")}
   status    ${d("[--json]")}                  diff    ${d("[--json]")}
   dev       ${d("[--push]")}                  resolve ${d("[--mine|--theirs]")}
-  doctor    ${d("[--json]")}                  ${d("validate format/compiler/editor/source/file contracts")}
+  doctor    ${d("[--json]")}                  ${d("validate contracts and audit the pulled document")}
 
 ${h("Pending source scaffolds")}
   class     ${d("new <Name> [--abstract]")}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neocompose/cli",
-  "version": "0.25.1",
+  "version": "0.25.2",
   "description": "Neo Compose native project-source CLI with bidirectional sync.",
   "license": "MIT",
   "type": "module",

package/skills/neocompose-cli/SKILL.md

@@ -9,7 +9,7 @@ description: >-
   `@neocompose/cli` or `node cli/bin/neo.mjs` in the neo-compose repository.
 ---
 
-<!-- reviewed-through-cli: 0.25.1 -->
+<!-- reviewed-through-cli: 0.25.2 -->
 
 # Neo Compose CLI
 

package/skills/neocompose-cli/references/cli-development.md

@@ -83,7 +83,7 @@ wrappers.
 The marker near the top of `SKILL.md` must exactly match the package version:
 
 ```html
-<!-- reviewed-through-cli: 0.25.1 -->
+<!-- reviewed-through-cli: 0.25.2 -->
 ```
 
 The quoted version above is checked too, so this instruction cannot go stale

package/skills/neocompose-cli/references/commands-and-sync.md

@@ -146,6 +146,13 @@ neo login [--api <url>] [--profile editor|release] [--save-project <id>]
 neo doctor
 ```
 
+`neo doctor` reports two different things. The authoring contracts (format,
+compiler, extension cache, source, files) decide its exit code; the document
+audit below them reports malformed records in the last pull and deliberately
+does not, so a project with records still to repair does not fail the command.
+`neo doctor --json` carries a `repair` entry per finding, which is what a
+targeted repair is handed instead of scanning a project to rediscover them.
+
 The Node CLI talks directly to authenticated Convex APIs through the
 session-gated CAS boundary. Tokens use the OS credential store when available
 and a protected file only as fallback. Use `NEO_COMPOSE_TOKEN` or