tenbo-dashboard 0.11.0 → 0.13.0

package/bin/tenbo-dashboard.mjs

@@ -43,6 +43,7 @@ const commands = {
   sync: 'scripts/sync.ts',
   archive: 'scripts/archive.ts',
   'commit-ready': 'scripts/commit-ready.ts',
+  'commit-context': 'scripts/commit-context.ts',
   item: 'scripts/item.ts',
   items: 'scripts/items.ts',
   list: 'scripts/items.ts',
@@ -51,8 +52,11 @@ const commands = {
   context: 'scripts/context.ts',
   impact: 'scripts/impact.ts',
   index: 'scripts/index.ts',
+  'code-map': 'scripts/code-map.ts',
   reminder: 'scripts/reminder.ts',
   hook: 'scripts/hook.ts',
+  reconcile: 'scripts/reconcile.ts',
+  hub: 'scripts/hub.ts',
 };
 
 // Documented aliases for the bare-launch behavior. Users (and agents) reading
@@ -100,9 +104,14 @@ ${topLevelItemHelpLines().join('\n')}
                                    [--type <type>] [--json]
   tenbo-dashboard context feature  Fetch agent planning context for a natural-language request
                                    --query "<request>" [--json]
+  tenbo-dashboard context session  Deterministic session-gate briefing bundle [--json]
+  tenbo-dashboard context item <id>  Deterministic per-item context bundle [--json]
   tenbo-dashboard impact           Map git changes to affected layers, docs, items,
                                    and verification checks [--since <ref>] [--json]
   tenbo-dashboard index            Build or refresh the derived source index [--if-stale] [--json]
+  tenbo-dashboard code-map generate  Regenerate the auto-generated structural region of a
+                                   layer's code-map.md from the source index
+                                   [--scope <id>] [--layer <id>] [--check] [--json]
   tenbo-dashboard reminder print   Print advisory session reminder text [--json]
   tenbo-dashboard validate         Run validation rules
   tenbo-dashboard init-check       Strict completeness check for fresh init (errors on missing skeletons, file_count:0, etc)
@@ -111,10 +120,28 @@ ${topLevelItemHelpLines().join('\n')}
   tenbo-dashboard archive          Move old done/dropped items to roadmap-archive.yaml
                                    [--scope <id>] [--days 30] [--max 20]
   tenbo-dashboard hook install     Install opt-in pre-commit validation hook
-                                   [--dry-run] [--force]
-  tenbo-dashboard hook uninstall   Remove the tenbo pre-commit hook (idempotent)
+                                   (or 'prepare-commit-msg' for commit-context
+                                   suggestions, or 'post-commit' for doc-flag
+                                   detection) [--dry-run] [--force]
+  tenbo-dashboard hook uninstall   Remove a tenbo hook (idempotent)
+                                   [pre-commit|prepare-commit-msg|post-commit]
   tenbo-dashboard commit-ready     Report branch, diff, validation, and staging gates
                                    without committing [--json]
+  tenbo-dashboard commit-context   Propose roadmap item refs + a draft commit message
+                                   from the pending diff [--since <ref>] [--json] [--hook-format]
+  tenbo-dashboard reconcile flag   Map a commit's diff to affected layers and append
+                                   pending-reconciliation doc-flag entries
+                                   [--since <ref>] [--dry-run] [--json]
+  tenbo-dashboard reconcile clear  Remove pending-reconciliation entries once a doc
+                                   update lands [--layer <scope:layer>] [--commit <sha>]
+  tenbo-dashboard hub start        Run a headless, API-only hub server in the
+                                   foreground (health+mutate only, no browser UI)
+                                   [--port <n>]
+  tenbo-dashboard hub ensure       Idempotent: start a hub for this repo if none
+                                   is running yet, else no-op [--json]
+  tenbo-dashboard hub stop         Stop this repo's running hub, if any [--json]
+  tenbo-dashboard hub status       Report whether a hub is running
+                                   (pid/port/uptime) [--json]
   tenbo-dashboard --version        Print package version
   tenbo-dashboard help             Show this help
 

package/package.json

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

package/scripts/cliArgs.ts

@@ -16,12 +16,25 @@ export function readRepeated(args: string[], flag: string): string[] {
   return out;
 }
 
-export function positionalArgs(args: string[]): string[] {
+export interface PositionalArgsOptions {
+  /**
+   * Flags that consume the token immediately after them (e.g. `--status
+   * done`). Any `--flag` NOT in this set is treated as boolean/valueless
+   * (e.g. `--json`, `--check`) — the token that follows it is left in place
+   * as a positional, regardless of where the flag appears among the args.
+   * Defaults to no value-taking flags, so bare `positionalArgs(args)` never
+   * consumes a token after a `--flag`.
+   */
+  valueFlags?: readonly string[];
+}
+
+export function positionalArgs(args: string[], options: PositionalArgsOptions = {}): string[] {
+  const valueFlags = new Set(options.valueFlags ?? []);
   const out: string[] = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg.startsWith('--')) {
-      if (args[i + 1] && !args[i + 1].startsWith('--')) i++;
+      if (valueFlags.has(arg) && i + 1 < args.length) i++;
       continue;
     }
     out.push(arg);

package/scripts/code-map.ts

@@ -0,0 +1,45 @@
+import { generateCodeMaps, isCodeMapGeneratorError } from '../src/api/lib/codeMapGenerator';
+import { hasFlag, readOption } from './cliArgs';
+import { fail, handleCliError, isMain, misuse, repoRootFromCwd, runMain, type CliResult } from './cliResult';
+
+const USAGE = 'Usage: tenbo-dashboard code-map generate [--scope <id>] [--layer <id>] [--check] [--json]';
+
+export function runCodeMapCli(repoRoot: string, args: string[]): CliResult {
+  const json = hasFlag(args, '--json');
+  const command = args.find((arg) => !arg.startsWith('--'));
+
+  if (command !== 'generate') {
+    return misuse(USAGE, json);
+  }
+
+  const scope = readOption(args, '--scope');
+  const layer = readOption(args, '--layer');
+  const check = hasFlag(args, '--check');
+
+  try {
+    const result = generateCodeMaps(repoRoot, { scope, layer, check });
+    const staleCount = result.stale_layers.length;
+    const isStaleFailure = check && staleCount > 0;
+    const summary = check
+      ? (isStaleFailure
+        ? `code-map: ${staleCount} layer(s) stale: ${result.stale_layers.join(', ')}\n`
+        : `code-map: ${result.layers.length} layer(s) checked, all fresh\n`)
+      : `code-map: ${result.layers.length} layer(s) generated (${staleCount} changed)\n`;
+
+    if (json) {
+      return { stdout: `${JSON.stringify(result, null, 2)}\n`, stderr: '', exitCode: isStaleFailure ? 1 : 0 };
+    }
+    return isStaleFailure
+      ? { stdout: '', stderr: summary, exitCode: 1 }
+      : { stdout: summary, stderr: '', exitCode: 0 };
+  } catch (err) {
+    if (isCodeMapGeneratorError(err)) {
+      return fail(err.code, err.message, json);
+    }
+    return handleCliError(err, json);
+  }
+}
+
+if (isMain(import.meta.url)) {
+  runMain(runCodeMapCli(repoRootFromCwd(), process.argv.slice(2)));
+}

package/scripts/commit-context.ts

@@ -0,0 +1,33 @@
+import { resolveCommitContext } from '../src/api/lib/commitContext';
+import { hasFlag, readOption } from './cliArgs';
+import { isMain, misuse, repoRootFromCwd, runMain, serialize, type CliResult } from './cliResult';
+
+export function runCommitContextCli(repoRoot: string, args: string[]): CliResult {
+  const json = hasFlag(args, '--json');
+  const hookFormat = hasFlag(args, '--hook-format');
+  const since = readOption(args, '--since');
+  if (args.includes('--since') && (!since || since.startsWith('--'))) {
+    return misuse('Usage: tenbo-dashboard commit-context [--since <ref>] [--json] [--hook-format]', json);
+  }
+
+  // resolveCommitContext is fail-open by design (never throws), so there is
+  // no try/catch here — any internal failure already surfaces as a payload
+  // with empty suggestions and a `note` explaining why.
+  const payload = resolveCommitContext(repoRoot, { since });
+
+  if (hookFormat) {
+    return { stdout: payload.hook_format ? `${payload.hook_format}\n` : '', stderr: '', exitCode: 0 };
+  }
+
+  const text = payload.suggestions.length
+    ? `${payload.suggestions.length} suggestion(s):\n${payload.suggestions
+        .map((s) => `  ${s.id} (${s.status}) ${s.title} — ${s.reason}`)
+        .join('\n')}\n\nDraft message:\n${payload.draft_message}\n`
+    : `${payload.note}\n${payload.draft_message ? `\nDraft message:\n${payload.draft_message}\n` : ''}`;
+
+  return serialize(payload, json, text);
+}
+
+if (isMain(import.meta.url)) {
+  runMain(runCommitContextCli(repoRootFromCwd(), process.argv.slice(2)));
+}

package/scripts/context.ts

@@ -1,7 +1,12 @@
-import { resolveFeatureContext } from '../src/api/lib/contextResolver';
-import { hasFlag, readOption } from './cliArgs';
+import { resolveFeatureContext, resolveItemContext, resolveSessionContext } from '../src/api/lib/contextResolver';
+import { hasFlag, positionalArgs, readOption } from './cliArgs';
 import { handleCliError, isMain, misuse, repoRootFromCwd, runMain, serialize, type CliResult } from './cliResult';
 
+const USAGE = 'Usage: tenbo context <feature|session|item> ... [--json]\n'
+  + '  tenbo context feature --query "<request>" [--json]\n'
+  + '  tenbo context session [--json]\n'
+  + '  tenbo context item <id> [--json]';
+
 export function runContextCli(repoRoot: string, args: string[]): CliResult {
   const json = hasFlag(args, '--json');
   const command = args.find((arg) => !arg.startsWith('--'));
@@ -18,7 +23,31 @@ export function runContextCli(repoRoot: string, args: string[]): CliResult {
       );
     }
 
-    return misuse('Usage: tenbo context feature --query "<request>" [--json]', json);
+    if (command === 'session') {
+      const bundle = resolveSessionContext(repoRoot);
+      return serialize(
+        bundle,
+        json,
+        `now: ${bundle.now.count} (${bundle.stale.now.length} stale), stale next: ${bundle.stale.next.length}\n`,
+      );
+    }
+
+    if (command === 'item') {
+      // `item` itself has no value-taking flags (only boolean --json), so
+      // any --flag encountered here never consumes the following token —
+      // this keeps `context item --json <id>` and `context item <id>
+      // --json` equivalent (td-032).
+      const [, itemId] = positionalArgs(args);
+      if (!itemId) return misuse('Usage: tenbo context item <id> [--json]', json);
+      const bundle = resolveItemContext(repoRoot, itemId);
+      return serialize(
+        bundle,
+        json,
+        `${bundle.item_id}: ${bundle.item.title} (${bundle.item.status})\n`,
+      );
+    }
+
+    return misuse(USAGE, json);
   } catch (err) {
     return handleCliError(err, json);
   }