toga-ai 1.0.922 → 1.0.923

package/.claude/settings.json

@@ -90,6 +90,16 @@
             "timeout": 3000
           }
         ]
+      },
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"$CLAUDE_PROJECT_DIR/.claude/hooks/toga/platform-reuse-reminder.js\"",
+            "timeout": 3000
+          }
+        ]
       }
     ],
     "PostToolUse": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toga-ai",
-  "version": "1.0.922",
+  "version": "1.0.923",
   "description": "TOGA Technology Team Claude Knowledge System — shared AI coding harness with skills, knowledge base CLI, and project installer for Claude Code.",
   "keywords": [
     "claude",

package/rules/common/architecture-principles.md

@@ -29,7 +29,8 @@ not a script. When a principle and a real constraint collide, reason it out and
 - **Data-drive the UI.** Labels, colors, options, config come from Surface/settings and
   `labelRecordFieldId` — not hardcoded. Model anything data-drivable through those layers.
 - **Reuse before build.** A fundamental shared component (the table first) belongs in `blox`,
-  themed per app — not copied.
+  themed per app — not copied. Nudged by `scripts/hooks/platform-reuse-reminder.js` on every
+  new `src/` file in a platform app or blox (silence: `TOGA_REUSE_REMINDER_DISABLED=1`).
 - **Standard before custom.** Discuss standard-vs-custom before adding any custom field.
 
 ## Reversibility gate

package/scripts/hooks/platform-reuse-reminder.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * platform-reuse-reminder.js — PRE-CREATE nudge to reuse before building in the 2.0
+ * platform apps.
+ *
+ * Why this exists: the platform has ~10 apps sharing one component library
+ * (toga25-blox). New pages keep getting fresh components, hooks and styles that already
+ * exist in blox or in another app. The "reuse before build" rule
+ * (rules/common/architecture-principles.md) is passive; this puts it in context at the
+ * moment a new file is about to be created.
+ *
+ * How it works: registered on PreToolUse for Write|Edit. It fires only when ALL hold:
+ *   - the target file does NOT exist yet (a new file),
+ *   - it ends .tsx / .ts / .css (not .test.ts / .d.ts),
+ *   - it sits under the `src/` of a platform app — a folder whose vite.config.ts calls
+ *     defineTogaApp — or under the `src/` of the toga25-blox repo itself.
+ * Then it adds a short reminder through the PreToolUse additionalContext channel.
+ * Once per file path per session (state file in the OS temp dir, keyed on session id).
+ *
+ * It never blocks. It always exits 0 and fails open on any error.
+ *
+ * Escape hatch: set TOGA_REUSE_REMINDER_DISABLED=1 to silence the reminder.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Single-source platform consolidation rule (lives in toga25-blox).
+const CONSOLIDATION_DOC = 'toga25-blox/docs/consolidation.md';
+const BLOX_INVENTORY = '../toga25-blox/INVENTORY.md';
+const APP_REUSE_DOC = 'docs/architecture/reusable-components.md';
+const BLOX_PACKAGE_NAME = '@toga/blox';
+const BLOX_DIR_NAME = 'toga25-blox';
+const MAX_WALK_UP_LEVELS = 15;
+const MAX_SEEN_PATHS = 500;
+
+function readPayload() {
+  let raw = '';
+  try { raw = fs.readFileSync(0, 'utf8'); } catch (e) { /* no stdin */ }
+  let data = {};
+  if (raw && raw.trim()) {
+    try { data = JSON.parse(raw); } catch (e) { data = {}; }
+  }
+  if (!data.tool_name && process.env.CLAUDE_TOOL_NAME) data.tool_name = process.env.CLAUDE_TOOL_NAME;
+  if (!data.tool_input && process.env.CLAUDE_TOOL_INPUT) {
+    try { data.tool_input = JSON.parse(process.env.CLAUDE_TOOL_INPUT); } catch (e) { /* ignore */ }
+  }
+  if (!data.session_id) data.session_id = process.env.CLAUDE_SESSION_ID || process.env.CLAUDE_CODE_SESSION_ID;
+  return data;
+}
+
+function isWatchedExtension(filePath) {
+  const p = filePath.toLowerCase();
+  if (p.endsWith('.d.ts') || p.endsWith('.test.ts') || p.endsWith('.test.tsx')) return false;
+  return /\.(tsx|ts|css)$/.test(p);
+}
+
+function isBloxRoot(dir) {
+  if (path.basename(dir).toLowerCase() !== BLOX_DIR_NAME) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+      return pkg && pkg.name === BLOX_PACKAGE_NAME;
+    } catch (e) { return false; }
+  }
+  return fs.existsSync(path.join(dir, 'package.json'));
+}
+
+function isPlatformAppRoot(dir) {
+  try {
+    return fs.readFileSync(path.join(dir, 'vite.config.ts'), 'utf8').includes('defineTogaApp');
+  } catch (e) { return false; }
+}
+
+/* Walk up from the file to the nearest project root. Returns { root, isBlox } when the
+ * nearest root is a platform app or blox, else null. The file must be under root/src/. */
+function findPlatformRoot(filePath) {
+  let dir = path.dirname(filePath);
+  for (let i = 0; i < MAX_WALK_UP_LEVELS; i++) {
+    const app = isPlatformAppRoot(dir);
+    const blox = !app && isBloxRoot(dir);
+    if (app || blox) {
+      const rel = path.relative(dir, filePath).replace(/\\/g, '/');
+      return rel.startsWith('src/') ? { root: dir, isBlox: blox } : null;
+    }
+    if (fs.existsSync(path.join(dir, 'package.json'))) return null; // some other project
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+
+function sessionKey(data) {
+  const sid = (data && data.session_id) || String(process.ppid || process.pid);
+  return String(sid).replace(/[^A-Za-z0-9_-]/g, '').slice(0, 64) || 'x';
+}
+
+/* True the first time this path is seen this session; records it. */
+function firstTimeThisSession(data, normPath) {
+  const sf = path.join(os.tmpdir(), 'toga-reuse-reminder-' + sessionKey(data) + '.json');
+  let seen = [];
+  try { seen = JSON.parse(fs.readFileSync(sf, 'utf8')) || []; } catch (e) { seen = []; }
+  if (!Array.isArray(seen)) seen = [];
+  if (seen.includes(normPath)) return false;
+  seen.push(normPath);
+  try { fs.writeFileSync(sf, JSON.stringify(seen.slice(-MAX_SEEN_PATHS))); } catch (e) { /* non-fatal */ }
+  return true;
+}
+
+function reminder(isBlox) {
+  const where = isBlox
+    ? 'New file in toga25-blox. Before creating it: check INVENTORY.md in this repo'
+    : 'New file in a platform app. Before creating it: check `' + BLOX_INVENTORY + '` and this app\'s `' +
+      APP_REUSE_DOC + '`';
+  return [
+    '<system-reminder>',
+    where + ' — reuse or extend an existing piece first.',
+    'If this duplicates something in another page or app, consolidate instead',
+    '(rule: `' + CONSOLIDATION_DOC + '`).',
+    '</system-reminder>',
+  ].join('\n');
+}
+
+function main() {
+  if (process.env.TOGA_REUSE_REMINDER_DISABLED === '1') return;
+
+  const data = readPayload();
+  if (!/^(Write|Edit)$/.test(data.tool_name || '')) return;
+
+  const input = data.tool_input || {};
+  const filePath = typeof input.file_path === 'string' ? input.file_path : '';
+  if (!filePath || !isWatchedExtension(filePath)) return;
+
+  const abs = path.resolve(data.cwd || process.cwd(), filePath);
+  if (fs.existsSync(abs)) return; // only new files
+
+  const hit = findPlatformRoot(abs);
+  if (!hit) return;
+
+  if (!firstTimeThisSession(data, abs.replace(/\\/g, '/').toLowerCase())) return;
+
+  console.log(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      additionalContext: reminder(hit.isBlox),
+    },
+  }));
+}
+
+try { main(); } catch (e) { /* fail-open: never block or brick an edit */ }
+process.exitCode = 0; // always 0; exitCode (not exit()) lets stdout flush on Windows pipes