tenbo-dashboard 0.2.0 → 0.3.0

package/README.md

@@ -47,9 +47,9 @@ npx tenbo-dashboard --version         # Print the installed version
 
 ## What is tenbo?
 
-A Claude Code skill that gives your AI coding assistant persistent project memory — architecture docs, roadmaps, and health signals that survive across sessions. The dashboard is the optional visual companion; the skill is the always-on conversational brain.
+An AI cofounder that gives your coding assistant persistent project memory — architecture docs, roadmaps, and health signals that survive across sessions. Available as a Claude Code skill and as a Cursor rule package; both editors share the same `.tenbo/` data and the same companion dashboard. The dashboard is the optional visual companion; the skill / rule is the always-on conversational brain.
 
-Install the skill: [github.com/poyi/tenbo](https://github.com/poyi/tenbo)
+Install: [github.com/poyi/tenbo](https://github.com/poyi/tenbo) (instructions for both Claude Code and Cursor)
 
 ## License
 

package/bin/tenbo-dashboard.mjs

@@ -38,6 +38,7 @@ const commands = {
   'next-id': 'scripts/next-id.ts',
   metrics: 'scripts/compute-metrics.ts',
   'init-check': 'scripts/init-check.ts',
+  sync: 'scripts/sync.ts',
 };
 
 function run(script, scriptArgs) {
@@ -65,6 +66,7 @@ tenbo-dashboard — local architecture dashboard for .tenbo/ repos
 
 Usage:
   tenbo-dashboard                  Launch the dashboard (http://localhost:5174)
+  tenbo-dashboard sync             Refresh tenbo state after a change (metrics + init-check + validate, surfaces new findings)
   tenbo-dashboard validate         Run validation rules
   tenbo-dashboard init-check       Strict completeness check for fresh init (errors on missing skeletons, file_count:0, etc)
   tenbo-dashboard next-id <prefix> Allocate next roadmap item ID

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tenbo-dashboard",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Local-first architecture dashboard and CLI tools for .tenbo/ repos",
   "type": "module",
   "license": "MIT",

package/scripts/sync.ts

@@ -0,0 +1,144 @@
+/**
+ * sync.ts — single command for "make tenbo state fresh after a change".
+ *
+ * Runs metrics --all (or --scope <id>) + init-check + validate, then prints
+ * a unified summary of NEW findings (severity >= warning) introduced since
+ * the prior metrics.json snapshot. Replaces three separate commands the
+ * skill used to invoke at init and completion time, eliminating the
+ * silent-staleness failure mode where an agent forgot one of the three.
+ *
+ * Exit codes:
+ *   0 — everything refreshed cleanly, no new errors
+ *   1 — an error in any step (validation failure, init defect, metrics throw)
+ *   2 — could not locate repo root
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { findRepoRoot } from '../src/api/lib/repoRoot';
+import { runComputeMetrics } from './compute-metrics';
+import { runInitCheck } from './init-check';
+import { readState } from '../src/api/lib/tenboFs';
+import { validate } from '../src/api/lib/validator';
+import type { ScopeMetrics } from '../src/types';
+
+interface NewFinding {
+  scope: string;
+  layer: string;
+  severity: string;
+  signal: string;
+  headline: string;
+}
+
+function readMetrics(metricsPath: string): ScopeMetrics | null {
+  try {
+    if (!fs.existsSync(metricsPath)) return null;
+    return JSON.parse(fs.readFileSync(metricsPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function findingKey(scope: string, f: { signal: string; layer: string; headline: string }): string {
+  return `${scope}::${f.signal}::${f.layer}::${f.headline}`;
+}
+
+interface SyncArgs {
+  repoRoot: string;
+  scope?: string; // single-scope refresh; omit to refresh all
+}
+
+export async function runSync(args: SyncArgs): Promise<number> {
+  const { repoRoot, scope } = args;
+
+  // Snapshot prior findings so we can diff after the refresh.
+  const state = readState(repoRoot);
+  const targetScopes = scope ? [scope] : state.scopes.map((s) => s.id);
+  const priorFindingKeys = new Set<string>();
+  for (const id of targetScopes) {
+    const m = readMetrics(path.join(repoRoot, '.tenbo', 'scopes', id, 'metrics.json'));
+    for (const f of m?.findings ?? []) priorFindingKeys.add(findingKey(id, f));
+  }
+
+  // 1. metrics
+  const metricsCode = await runComputeMetrics({
+    repoRoot,
+    all: !scope,
+    scope,
+  });
+  if (metricsCode !== 0) {
+    process.stderr.write('sync: metrics step failed\n');
+    return 1;
+  }
+
+  // 2. init-check
+  const { defects } = runInitCheck(repoRoot);
+  if (defects.length > 0) {
+    process.stderr.write(`sync: init-check FAILED — ${defects.length} init defect(s):\n`);
+    for (const d of defects) {
+      const loc = d.scope ? ` [${d.scope}${d.layerId ? `/${d.layerId}` : ''}]` : '';
+      process.stderr.write(`  ❌${loc} ${d.message}\n`);
+    }
+    return 1;
+  }
+
+  // 3. validate (re-read state after metrics may have changed scope dirs)
+  const stateAfter = readState(repoRoot);
+  const result = validate(stateAfter);
+  if (result.errors.length > 0) {
+    process.stderr.write(`sync: validate FAILED — ${result.errors.length} error(s):\n`);
+    for (const e of result.errors) process.stderr.write(`  ❌ ${e.message}\n`);
+    return 1;
+  }
+
+  // 4. Diff findings: surface NEW critical/warning findings introduced this run.
+  const newFindings: NewFinding[] = [];
+  for (const id of targetScopes) {
+    const m = readMetrics(path.join(repoRoot, '.tenbo', 'scopes', id, 'metrics.json'));
+    for (const f of m?.findings ?? []) {
+      if (f.severity === 'info') continue;
+      if (priorFindingKeys.has(findingKey(id, f))) continue;
+      newFindings.push({
+        scope: id,
+        layer: f.layer,
+        severity: f.severity,
+        signal: f.signal,
+        headline: f.headline,
+      });
+    }
+  }
+
+  // 5. Summary line + (optional) new-finding lines.
+  const scopeLabel = scope ? `scope "${scope}"` : `${targetScopes.length} scope(s)`;
+  if (newFindings.length === 0) {
+    process.stdout.write(`sync: ${scopeLabel} fresh. No new errors, no new warning/critical findings.\n`);
+    return 0;
+  }
+  process.stdout.write(`sync: ${scopeLabel} fresh. ${newFindings.length} new finding(s) since last refresh:\n`);
+  for (const f of newFindings) {
+    const icon = f.severity === 'critical' ? '🔴' : '⚠️';
+    process.stdout.write(`  ${icon} [${f.scope}/${f.layer}] ${f.signal}: ${f.headline}\n`);
+  }
+  return 0;
+}
+
+function isMain(): boolean {
+  try {
+    const invoked = process.argv[1] ? path.resolve(process.argv[1]) : '';
+    const here = path.resolve(new URL(import.meta.url).pathname);
+    return invoked === here;
+  } catch {
+    return false;
+  }
+}
+
+if (isMain()) {
+  const args = process.argv.slice(2);
+  const scopeIdx = args.indexOf('--scope');
+  const scope = scopeIdx >= 0 ? args[scopeIdx + 1] : undefined;
+  const repoRoot = findRepoRoot(process.cwd());
+  if (!repoRoot) {
+    process.stderr.write('sync: unable to find repo root (no .git in any parent directory)\n');
+    process.exit(2);
+  }
+  runSync({ repoRoot, scope }).then((code) => process.exit(code));
+}