@smartmemory/compose 0.1.33-beta → 0.1.35-beta

package/lib/tracker/local-provider.js

@@ -0,0 +1,202 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, renameSync } from 'fs';
+import { join, dirname } from 'path';
+
+import { readFeature, listFeatures as listFeaturesRaw, writeFeature } from '../feature-json.js';
+import { loadFeaturesDir } from '../project-paths.js';
+import { TrackerProvider, CAP } from './provider.js';
+
+import { setFeatureStatus, addRoadmapEntry as addRoadmapEntryRaw } from '../feature-writer.js';
+import { recordCompletion as recordCompletionRaw } from '../completion-writer.js';
+import { addChangelogEntry } from '../changelog-writer.js';
+import { appendEvent as appendEventRaw, readEvents as readEventsRaw } from '../feature-events.js';
+import { writeRoadmap } from '../roadmap-gen.js';
+import { writeJournalEntry as writeJournalEntryRaw, getJournalEntries } from '../journal-writer.js';
+
+// Normalized event type map: maps raw writer tool strings → cross-provider type tokens.
+// Readers downstream use `type`, never `tool`, for portability across providers.
+const TOOL_TYPE = {
+  set_feature_status:  'status',
+  record_completion:   'completion',
+  add_roadmap_entry:   'roadmap',
+  add_changelog_entry: 'changelog',
+  write_journal_entry: 'journal',
+  link_artifact:       'artifact',
+  link_features:       'link',
+  propose_followup:    'followup',
+  roadmap_drift:       'drift',
+};
+
+// Inverse map: normalized type token → raw writer tool string (for write-side symmetry).
+const TYPE_TOOL = Object.fromEntries(Object.entries(TOOL_TYPE).map(([tool, type]) => [type, tool]));
+
+export class LocalFileProvider extends TrackerProvider {
+  name() { return 'local'; }
+
+  capabilities() {
+    return new Set([CAP.FEATURES, CAP.EVENTS, CAP.ROADMAP, CAP.CHANGELOG, CAP.JOURNAL, CAP.VISION]);
+  }
+
+  async init(cwd) {
+    this.cwd = cwd;
+    this.featuresDir = loadFeaturesDir(cwd);
+    return this;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Feature CRUD
+  // ---------------------------------------------------------------------------
+
+  async getFeature(code) {
+    return readFeature(this.cwd, code, this.featuresDir);
+  }
+
+  async listFeatures() {
+    return listFeaturesRaw(this.cwd, this.featuresDir);
+  }
+
+  async createFeature(code, obj) {
+    const existing = readFeature(this.cwd, code, this.featuresDir);
+    if (existing) return existing;
+    // writeFeature takes (cwd, featureObj, featuresDir) — featureObj.code drives the path
+    writeFeature(this.cwd, { ...obj, code }, this.featuresDir);
+    return readFeature(this.cwd, code, this.featuresDir);
+  }
+
+  async putFeature(code, obj) {
+    const cur = readFeature(this.cwd, code, this.featuresDir);
+    if (cur && Object.prototype.hasOwnProperty.call(obj, 'status') && obj.status !== cur.status) {
+      throw new Error(`putFeature: status delta (${cur.status}->${obj.status}) not allowed; use setStatus`);
+    }
+    writeFeature(this.cwd, { ...obj, code }, this.featuresDir);
+    return readFeature(this.cwd, code, this.featuresDir);
+  }
+
+  // Write full feature object including status with NO transition policy or events.
+  // Used by feature-writer.setFeatureStatus after it has validated the transition itself.
+  async persistFeatureRaw(code, obj) {
+    writeFeature(this.cwd, { ...obj, code }, this.featuresDir);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Status + Completion
+  // ---------------------------------------------------------------------------
+
+  async setStatus(code, to, meta = {}) {
+    return setFeatureStatus(this.cwd, { code, status: to, ...meta });
+  }
+
+  async recordCompletion(code, rec) {
+    return recordCompletionRaw(this.cwd, { feature_code: code, ...rec });
+  }
+
+  // ---------------------------------------------------------------------------
+  // Roadmap
+  // ---------------------------------------------------------------------------
+
+  async addRoadmapEntry(args) {
+    return addRoadmapEntryRaw(this.cwd, args);
+  }
+
+  async renderRoadmap() {
+    return writeRoadmap(this.cwd);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Events — normalize raw writer `tool` field to cross-provider `type` token
+  // ---------------------------------------------------------------------------
+
+  async appendEvent(code, event) {
+    // Validate that we can resolve a tool name (writers always include `tool`;
+    // this guard exists for callers that supply a normalized `type` alias instead).
+    const tool = event.tool ?? TYPE_TOOL[event.type];
+    if (!tool) throw new Error(`appendEvent: cannot resolve writer tool from event (need .tool or a known .type; got type=${event.type})`);
+
+    // Strip only the normalized `type` alias (never stored in the raw JSONL).
+    const { type, ...rest } = event;
+
+    // KEY-ORDER GUARANTEE for the WRITER PATH:
+    // Writers always include `tool` AND `code` in their event objects in the correct
+    // key order, so `rest` already contains them — forwarding `rest` directly
+    // preserves the writer's original key order and produces byte-identical JSONL
+    // output to the pre-fix direct call path.
+    //
+    // For DIRECT PROVIDER CALLERS (e.g. conformance tests) that pass only `type`
+    // (no `tool`) and/or omit `code`, inject the resolved values now.  These callers
+    // have no pre-existing key order to preserve, so insertion order doesn't matter
+    // for byte-identicality (that invariant only applies to the writer path above).
+    if (rest.tool && rest.code !== undefined) {
+      // Writer path: all fields already present in correct order — forward as-is.
+      return appendEventRaw(this.cwd, rest);
+    }
+    // Direct-caller path: inject any missing routing fields.
+    const payload = { ...rest };
+    if (!payload.tool) payload.tool = tool;
+    if (payload.code === undefined) payload.code = code;
+    return appendEventRaw(this.cwd, payload);
+  }
+
+  async readEvents(code) {
+    const raw = readEventsRaw(this.cwd, { code });
+    return raw.map(e => ({ ...e, type: e.type ?? TOOL_TYPE[e.tool] ?? e.tool }));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Changelog
+  // ---------------------------------------------------------------------------
+
+  async getChangelog() {
+    const p = join(this.cwd, 'CHANGELOG.md');
+    if (!existsSync(p)) return '';
+    return readFileSync(p, 'utf-8');
+  }
+
+  async putChangelog(text) {
+    const p = join(this.cwd, 'CHANGELOG.md');
+    const tmp = p + '.tmp';
+    mkdirSync(dirname(p), { recursive: true });
+    try {
+      writeFileSync(tmp, text);
+      renameSync(tmp, p);
+    } catch (err) {
+      try { if (existsSync(tmp)) unlinkSync(tmp); } catch { /* ignore */ }
+      throw err;
+    }
+  }
+
+  async appendChangelog(entry) {
+    return addChangelogEntry(this.cwd, entry);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Journal
+  // ---------------------------------------------------------------------------
+
+  async readJournal() {
+    return getJournalEntries(this.cwd);
+  }
+
+  async writeJournalEntry(e) {
+    return writeJournalEntryRaw(this.cwd, e);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Vision state — instantiate VisionStore per call (cwd-scoped, no singleton)
+  // ---------------------------------------------------------------------------
+
+  async getVisionState() {
+    const { VisionStore } = await import('../../server/vision-store.js');
+    const store = new VisionStore(join(this.cwd, '.compose', 'data'));
+    return store.getState();
+  }
+
+  async putVisionState(s) {
+    const { VisionStore } = await import('../../server/vision-store.js');
+    const store = new VisionStore(join(this.cwd, '.compose', 'data'));
+    // Restore items, connections, gates from the supplied state snapshot
+    store.items       = new Map((s.items       ?? []).map(i => [i.id, i]));
+    store.connections = new Map((s.connections ?? []).map(c => [c.id, c]));
+    store.gates       = new Map((s.gates       ?? []).map(g => [g.id, g]));
+    store._save();
+    return store.getState();
+  }
+}

package/lib/tracker/provider.js

@@ -0,0 +1,40 @@
+export const CAP = Object.freeze({
+  FEATURES: 'FEATURES', EVENTS: 'EVENTS', ROADMAP: 'ROADMAP',
+  CHANGELOG: 'CHANGELOG', JOURNAL: 'JOURNAL', VISION: 'VISION',
+});
+
+export class TrackerConfigError extends Error {
+  constructor(message, detail = {}) { super(message); this.name = 'TrackerConfigError'; this.detail = detail; }
+}
+export class TrackerConflictError extends Error {
+  constructor(message, detail = {}) { super(message); this.name = 'TrackerConflictError'; this.detail = detail; }
+}
+
+const NI = (m) => { throw new Error(`TrackerProvider.${m}: not implemented`); };
+
+export class TrackerProvider {
+  name() { return NI('name'); }
+  capabilities() { return new Set(); }
+  async init(_cwd, _config) { return this; }
+  async health() { return { ok: true, provider: this.name?.() ?? 'base', canonical: 'local', pendingOps: 0, conflicts: 0, mixedSources: [] }; }
+  async sync() { return { drained: 0, quarantined: 0 }; }
+  async getFeature(_code) { return NI('getFeature'); }
+  async listFeatures() { return NI('listFeatures'); }
+  async createFeature(_code, _obj) { return NI('createFeature'); }
+  async putFeature(_code, _obj) { return NI('putFeature'); }
+  async persistFeatureRaw(_code, _obj) { return NI('persistFeatureRaw'); }
+  async deleteFeature(_code) { return NI('deleteFeature'); }
+  async setStatus(_code, _to, _meta) { return NI('setStatus'); }
+  async recordCompletion(_code, _rec) { return NI('recordCompletion'); }
+  async addRoadmapEntry(_args) { return NI('addRoadmapEntry'); }
+  async appendEvent(_code, _event) { return NI('appendEvent'); }
+  async readEvents(_code) { return NI('readEvents'); }
+  async renderRoadmap() { return NI('renderRoadmap'); }
+  async getChangelog() { return NI('getChangelog'); }
+  async putChangelog(_text) { return NI('putChangelog'); }
+  async appendChangelog(_entry) { return NI('appendChangelog'); }
+  async readJournal() { return NI('readJournal'); }
+  async writeJournalEntry(_e) { return NI('writeJournalEntry'); }
+  async getVisionState() { return NI('getVisionState'); }
+  async putVisionState(_s) { return NI('putVisionState'); }
+}

package/lib/tracker/sync-engine.js

@@ -0,0 +1,131 @@
+import { openSync, writeSync, fsyncSync, closeSync, readFileSync, existsSync, writeFileSync, renameSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { randomUUID } from 'crypto';
+
+const OPLOG = 'tracker-oplog.jsonl';
+const QUAR  = 'tracker-quarantine.jsonl';
+
+export class OpLog {
+  constructor(dataDir) {
+    this.dir = dataDir;
+    this.path = join(dataDir, OPLOG);
+    this.quarPath = join(dataDir, QUAR);
+  }
+  _all() {
+    if (!existsSync(this.path)) return [];
+    return readFileSync(this.path, 'utf8').split('\n').filter(Boolean).map(JSON.parse);
+  }
+  async pending() { return this._all().filter(o => o.state === 'pending'); }
+  async quarantined() {
+    if (!existsSync(this.quarPath)) return [];
+    return readFileSync(this.quarPath, 'utf8').split('\n').filter(Boolean).map(JSON.parse);
+  }
+  async append(op) {
+    if (op.idempotencyKey) {
+      const dup = this._all().find(o => o.idempotencyKey === op.idempotencyKey);
+      if (dup) return dup;
+    }
+    const { id: _i, ts: _t, state: _s, attempts: _a, ...safe } = op;
+    const rec = { ...safe, id: randomUUID(), ts: Date.now(), state: 'pending', attempts: 0 };
+    const fd = openSync(this.path, 'a');
+    try { writeSync(fd, JSON.stringify(rec) + '\n'); fsyncSync(fd); } finally { closeSync(fd); }
+    return rec;
+  }
+  _rewrite(records) {
+    const tmp = this.path + '.tmp';
+    writeFileSync(tmp, records.map(r => JSON.stringify(r)).join('\n') + (records.length ? '\n' : ''));
+    renameSync(tmp, this.path);
+  }
+  async resolve(id) { this._rewrite(this._all().filter(o => o.id !== id)); }
+  async bumpAttempt(id) {
+    const all = this._all();
+    const o = all.find(x => x.id === id); if (o) o.attempts += 1;
+    this._rewrite(all);
+    return o;
+  }
+  async quarantine(id, reason) {
+    const all = this._all();
+    const o = all.find(x => x.id === id);
+    if (o) {
+      const fd = openSync(this.quarPath, 'a');
+      try { writeSync(fd, JSON.stringify({ ...o, state: 'quarantined', reason }) + '\n'); fsyncSync(fd); }
+      finally { closeSync(fd); }
+      this._rewrite(all.filter(x => x.id !== id));
+    }
+  }
+}
+
+export class Cache {
+  constructor(dataDir) {
+    this.dir = join(dataDir, 'tracker-cache');
+    mkdirSync(this.dir, { recursive: true });
+    this.path = join(this.dir, 'features.json');
+  }
+  _load() { return existsSync(this.path) ? JSON.parse(readFileSync(this.path, 'utf8')) : {}; }
+  _save(s) { const t = this.path + '.tmp'; writeFileSync(t, JSON.stringify(s, null, 2)); renameSync(t, this.path); }
+  async get(code) { return this._load()[code]?.value ?? null; }
+  async version(code) { return this._load()[code]?.version ?? null; }
+  async put(code, value, { version, pending = false } = {}) {
+    const s = this._load();
+    s[code] = { value, version: version ?? s[code]?.version ?? null,
+                pending: pending || s[code]?.pending || false };
+    this._save(s);
+  }
+  async markPending(code) { const s = this._load(); if (s[code]) { s[code].pending = true; this._save(s); } }
+  async clearPending(code) { const s = this._load(); if (s[code]) { s[code].pending = false; this._save(s); } }
+  async all() { return this._load(); }
+  async applyRemote(code, value, { version }) {
+    const s = this._load();
+    if (s[code]?.pending) return; // shadow: never roll back an entry with a pending op
+    s[code] = { value, version, pending: false };
+    this._save(s);
+  }
+}
+
+export class ConflictLedger {
+  constructor(dir) { this.path = join(dir, 'tracker-conflicts.jsonl'); }
+  async record(entry) {
+    const fd = openSync(this.path, 'a');
+    try { writeSync(fd, JSON.stringify({ ts: Date.now(), ...entry }) + '\n'); fsyncSync(fd); }
+    finally { closeSync(fd); }
+  }
+  async all() {
+    if (!existsSync(this.path)) return [];
+    return readFileSync(this.path, 'utf8').split('\n').filter(Boolean).map(JSON.parse);
+  }
+}
+
+export class Reconciler {
+  constructor({ log, cache, dir, apply, maxAttempts = 5 }) {
+    this.log = log; this.cache = cache; this.dir = dir;
+    this.apply = apply; this.maxAttempts = maxAttempts;
+    this.ledger = new ConflictLedger(dir);
+  }
+  async flush() {
+    for (const op of await this.log.pending()) {
+      try {
+        const res = await this.apply(op);
+        await this.cache.clearPending(op.code);
+        if (res?.version) {
+          const cur = await this.cache.get(op.code);
+          if (cur) await this.cache.applyRemote(op.code, cur, { version: res.version });
+        }
+        await this.log.resolve(op.id);
+      } catch (e) {
+        if (e.casMismatch) {
+          await this.ledger.record({ code: op.code, opId: op.id, kind: 'cas',
+            baseVersion: op.baseVersion, remoteVersion: e.casMismatch.remoteVersion });
+          await this.log.quarantine(op.id, 'cas');
+          continue;
+        }
+        if (e.rateLimit) { await new Promise(r => setTimeout(r, Math.min(e.rateLimit.resetMs ?? 1000, 60000))); }
+        const bumped = await this.log.bumpAttempt(op.id);
+        if (bumped && bumped.attempts >= this.maxAttempts) {
+          await this.ledger.record({ code: op.code, opId: op.id, kind: 'poison', error: String(e) });
+          await this.log.quarantine(op.id, 'poison');
+        }
+        break; // FIFO: stop on first unresolved op so ordering is preserved
+      }
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartmemory/compose",
-  "version": "0.1.33-beta",
+  "version": "0.1.35-beta",
   "description": "Structured AI dev pipeline — goal-to-product orchestration with gates, iteration loops, and feature lifecycle management.",
   "author": "SmartMemory",
   "license": "MIT",
@@ -19,8 +19,9 @@
     "dev:client": "vite",
     "build": "vite build",
     "preview": "vite preview",
-    "test": "node --test test/*.test.js test/comp-obs-branch/*.test.js && npm run test:ui",
+    "test": "node --test test/*.test.js test/comp-obs-branch/*.test.js && npm run test:ui && npm run test:tracker",
     "test:ui": "vitest run",
+    "test:tracker": "vitest run --config vitest.tracker.config.js",
     "test:integration": "node --test test/integration/*.test.js",
     "test:wave-6": "node --test test/wave-6-integration.test.js test/wave-6-contract-compliance.test.js",
     "prepublishOnly": "npm run build"

package/dist/assets/channel-9SpKIWte.js

@@ -1 +0,0 @@
-import{U as a,C as n}from"./App-1c_7rycT.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/assets/classDiagram-4FO5ZUOK-1x8GC0fS.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as e,C as t}from"./chunk-727SXJPM-CkHPoJZX.js";import{b as i}from"./App-1c_7rycT.js";import"./chunk-FMBD7UC4-Dzli17sA.js";import"./chunk-ND2GUHAM-BZM0pKix.js";import"./chunk-55IACEB6-BmobEJTk.js";import"./chunk-2J33WTMH-VIEW3rXo.js";import"./mobile-CsuriFuT.js";import"./index-CCu-56GD.js";import"./graph-DPbJeZyN.js";var f={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{f as diagram};

package/dist/assets/classDiagram-v2-Q7XG4LA2-1x8GC0fS.js

@@ -1 +0,0 @@
-import{s as a,a as s,c as e,C as t}from"./chunk-727SXJPM-CkHPoJZX.js";import{b as i}from"./App-1c_7rycT.js";import"./chunk-FMBD7UC4-Dzli17sA.js";import"./chunk-ND2GUHAM-BZM0pKix.js";import"./chunk-55IACEB6-BmobEJTk.js";import"./chunk-2J33WTMH-VIEW3rXo.js";import"./mobile-CsuriFuT.js";import"./index-CCu-56GD.js";import"./graph-DPbJeZyN.js";var f={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{f as diagram};

package/dist/assets/stateDiagram-v2-BHNVJYJU-CpvhwvDI.js

@@ -1 +0,0 @@
-import{b as r,a as e,s as a,S as s}from"./chunk-AQP2D5EJ-DhlFWYJI.js";import{b as i}from"./App-1c_7rycT.js";import"./chunk-55IACEB6-BmobEJTk.js";import"./chunk-2J33WTMH-VIEW3rXo.js";import"./mobile-CsuriFuT.js";import"./index-CCu-56GD.js";import"./graph-DPbJeZyN.js";var b={parser:a,get db(){return new s(2)},renderer:e,styles:r,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{b as diagram};