@a-company/paradigm 3.0.2 → 3.1.0

package/dist/habits-YVCOZ2LC.js

@@ -0,0 +1,485 @@
+#!/usr/bin/env node
+import "./chunk-MO4EEYFW.js";
+
+// src/commands/habits/index.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import chalk from "chalk";
+import * as yaml2 from "js-yaml";
+
+// src/core/habits/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+import * as yaml from "js-yaml";
+
+// src/core/habits/seed-habits.json
+var seed_habits_default = [
+  {
+    id: "explore-before-implement",
+    name: "Explore Before Implementing",
+    description: "Call ripple/navigate/search before modifying existing symbols to understand impact",
+    category: "discovery",
+    trigger: "preflight",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_ripple", "paradigm_navigate", "paradigm_search", "paradigm_related"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "ripple-before-modify",
+    name: "Ripple Before Modifying",
+    description: "Run ripple analysis before modifying symbols with dependents",
+    category: "discovery",
+    trigger: "preflight",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_ripple"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "check-fragility",
+    name: "Check Fragility",
+    description: "Check history fragility for symbols before modifying frequently-broken code",
+    category: "discovery",
+    trigger: "preflight",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_history_fragility"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "wisdom-before-implement",
+    name: "Check Team Wisdom",
+    description: "Check team wisdom (preferences, antipatterns, decisions) before implementing",
+    category: "collaboration",
+    trigger: "preflight",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_wisdom_context", "paradigm_wisdom_expert"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "verify-before-done",
+    name: "Verify Before Done",
+    description: "Run postflight compliance checks before finishing a session",
+    category: "verification",
+    trigger: "on-stop",
+    severity: "warn",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_pm_postflight"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "postflight-compliance",
+    name: "Postflight Compliance",
+    description: "Ensure postflight checks pass without errors before finishing",
+    category: "verification",
+    trigger: "on-stop",
+    severity: "advisory",
+    check: {
+      type: "tool-called",
+      params: {
+        tools: ["paradigm_pm_postflight", "paradigm_reindex"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "test-new-components",
+    name: "Test New Components",
+    description: "New components should have associated tests or test plan documented",
+    category: "testing",
+    trigger: "postflight",
+    severity: "advisory",
+    check: {
+      type: "tests-exist",
+      params: {
+        patterns: ["**/*.test.*", "**/*.spec.*", "**/tests/**"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "purpose-coverage",
+    name: "Purpose File Coverage",
+    description: "All modified source directories should have .purpose file coverage",
+    category: "documentation",
+    trigger: "postflight",
+    severity: "warn",
+    check: {
+      type: "file-exists",
+      params: {
+        patterns: ["**/.purpose"]
+      }
+    },
+    enabled: true
+  },
+  {
+    id: "record-lore-for-significant",
+    name: "Record Lore for Significant Changes",
+    description: "Sessions modifying 3+ files should record a lore entry",
+    category: "documentation",
+    trigger: "on-stop",
+    severity: "warn",
+    check: {
+      type: "lore-recorded",
+      params: {}
+    },
+    enabled: true
+  },
+  {
+    id: "gates-for-routes",
+    name: "Gates for Routes",
+    description: "API routes should have corresponding gate declarations in portal.yaml",
+    category: "security",
+    trigger: "postflight",
+    severity: "warn",
+    check: {
+      type: "gates-declared",
+      params: {
+        requireRoutes: true
+      }
+    },
+    enabled: true
+  }
+];
+
+// src/core/habits/loader.ts
+var SEED_HABITS = seed_habits_default;
+var HABITS_CACHE_TTL_MS = 30 * 1e3;
+var habitsCache = /* @__PURE__ */ new Map();
+function loadHabits(rootDir) {
+  const absoluteRoot = path.resolve(rootDir);
+  const cached = habitsCache.get(absoluteRoot);
+  if (cached && Date.now() - cached.loadedAt < HABITS_CACHE_TTL_MS) {
+    return cached.habits;
+  }
+  const habits = loadHabitsFresh(absoluteRoot);
+  habitsCache.set(absoluteRoot, {
+    habits,
+    loadedAt: Date.now()
+  });
+  return habits;
+}
+function loadHabitsFresh(rootDir) {
+  const habitsById = /* @__PURE__ */ new Map();
+  for (const seed of SEED_HABITS) {
+    habitsById.set(seed.id, { ...seed });
+  }
+  const globalHabitsPath = path.join(
+    process.env.HOME || process.env.USERPROFILE || "~",
+    ".paradigm",
+    "habits.yaml"
+  );
+  const globalConfig = loadHabitsYaml(globalHabitsPath);
+  if (globalConfig) {
+    mergeHabits(habitsById, globalConfig);
+  }
+  const projectHabitsPath = path.join(rootDir, ".paradigm", "habits.yaml");
+  const projectConfig = loadHabitsYaml(projectHabitsPath);
+  if (projectConfig) {
+    mergeHabits(habitsById, projectConfig);
+  }
+  return Array.from(habitsById.values());
+}
+function loadHabitsYaml(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const content = fs.readFileSync(filePath, "utf8");
+    return yaml.load(content);
+  } catch {
+    return null;
+  }
+}
+function mergeHabits(habitsById, config) {
+  if (config.habits) {
+    for (const habit of config.habits) {
+      habitsById.set(habit.id, { ...habit });
+    }
+  }
+  if (config.overrides) {
+    for (const [habitId, override] of Object.entries(config.overrides)) {
+      const existing = habitsById.get(habitId);
+      if (existing) {
+        applyOverride(existing, override);
+      }
+    }
+  }
+}
+function applyOverride(habit, override) {
+  if (override.severity !== void 0) {
+    habit.severity = override.severity;
+  }
+  if (override.enabled !== void 0) {
+    habit.enabled = override.enabled;
+  }
+}
+function getEnabledHabits(habits) {
+  return habits.filter((h) => h.enabled);
+}
+function invalidateHabitsCache(rootDir) {
+  const absoluteRoot = path.resolve(rootDir);
+  habitsCache.delete(absoluteRoot);
+}
+
+// src/commands/habits/index.ts
+var HABITS_FILE = ".paradigm/habits.yaml";
+async function habitsListCommand(options) {
+  const rootDir = process.cwd();
+  let habits;
+  try {
+    habits = loadHabits(rootDir);
+  } catch (err) {
+    console.log(chalk.red("Failed to load habits:"), err.message);
+    return;
+  }
+  if (options.trigger) {
+    habits = habits.filter((h) => h.trigger === options.trigger);
+  }
+  if (options.category) {
+    habits = habits.filter((h) => h.category === options.category);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(habits, null, 2));
+    return;
+  }
+  const enabled = habits.filter((h) => h.enabled);
+  const disabled = habits.filter((h) => !h.enabled);
+  console.log(chalk.magenta(`
+  Habits (${enabled.length} active, ${disabled.length} disabled)
+`));
+  const triggers = ["preflight", "postflight", "on-stop", "on-commit"];
+  for (const trigger of triggers) {
+    const group = habits.filter((h) => h.trigger === trigger);
+    if (group.length === 0) continue;
+    console.log(chalk.cyan(`  ${trigger}:`));
+    for (const h of group) {
+      const status = h.enabled ? chalk.green("ON") : chalk.gray("OFF");
+      const severity = h.severity === "block" ? chalk.red(h.severity) : h.severity === "warn" ? chalk.yellow(h.severity) : chalk.gray(h.severity);
+      console.log(`    ${status} ${chalk.white(h.id)} [${severity}] - ${h.name}`);
+      console.log(chalk.gray(`       ${h.description}`));
+    }
+    console.log();
+  }
+  const projectConfig = path2.join(rootDir, HABITS_FILE);
+  if (fs2.existsSync(projectConfig)) {
+    console.log(chalk.gray(`  Config: ${HABITS_FILE}`));
+  } else {
+    console.log(chalk.gray(`  Config: using seed habits only (run 'paradigm habits init' to customize)`));
+  }
+  console.log();
+}
+async function habitsStatusCommand(options) {
+  const rootDir = process.cwd();
+  let habits;
+  try {
+    habits = loadHabits(rootDir);
+  } catch (err) {
+    console.log(chalk.red("Failed to load habits:"), err.message);
+    return;
+  }
+  const enabled = getEnabledHabits(habits);
+  let practiceData = null;
+  try {
+    const { SentinelStorage } = await import("./dist-GPQ4LAY3.js");
+    const sentinelDir = path2.join(rootDir, ".paradigm", "sentinel");
+    if (fs2.existsSync(sentinelDir)) {
+      const storage = new SentinelStorage(sentinelDir);
+      const period = options.period || "30d";
+      const days = parseInt(period.replace("d", ""), 10) || 30;
+      const dateFrom = period === "all" ? void 0 : new Date(Date.now() - days * 24 * 60 * 60 * 1e3).toISOString();
+      const compliance = storage.getComplianceRate({ dateFrom });
+      const events = storage.getPracticeEvents({ dateFrom, limit: 500 });
+      const catStats = /* @__PURE__ */ new Map();
+      for (const event of events) {
+        const cat = event.habitCategory;
+        const existing = catStats.get(cat) || { followed: 0, skipped: 0, partial: 0 };
+        existing[event.result]++;
+        catStats.set(cat, existing);
+      }
+      const byCategory = Array.from(catStats.entries()).map(([category, stats]) => {
+        const total = stats.followed + stats.skipped + stats.partial;
+        const rate = total > 0 ? Math.round((stats.followed + stats.partial * 0.5) / total * 100) : 100;
+        return { category, rate, total };
+      }).sort((a, b) => a.rate - b.rate);
+      practiceData = {
+        total: compliance.total,
+        followed: compliance.followed,
+        skipped: compliance.skipped,
+        partial: compliance.partial,
+        rate: compliance.rate,
+        byCategory
+      };
+    }
+  } catch {
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      habits: { total: habits.length, enabled: enabled.length },
+      practice: practiceData
+    }, null, 2));
+    return;
+  }
+  console.log(chalk.magenta("\n  Habits Practice Profile\n"));
+  console.log(chalk.white(`  Total habits: ${habits.length} (${enabled.length} active)`));
+  const byTrigger = /* @__PURE__ */ new Map();
+  for (const h of enabled) {
+    byTrigger.set(h.trigger, (byTrigger.get(h.trigger) || 0) + 1);
+  }
+  for (const [trigger, count] of byTrigger) {
+    console.log(chalk.gray(`    ${trigger}: ${count} habit(s)`));
+  }
+  console.log();
+  if (practiceData && practiceData.total > 0) {
+    const rateColor = practiceData.rate >= 80 ? chalk.green : practiceData.rate >= 60 ? chalk.yellow : chalk.red;
+    console.log(chalk.white(`  Compliance Rate: ${rateColor(`${practiceData.rate}%`)}`));
+    console.log(chalk.gray(`    Followed: ${practiceData.followed} | Skipped: ${practiceData.skipped} | Partial: ${practiceData.partial}`));
+    console.log(chalk.gray(`    Total events: ${practiceData.total}
+`));
+    if (practiceData.byCategory.length > 0) {
+      console.log(chalk.white("  By Category:"));
+      for (const cat of practiceData.byCategory) {
+        const catColor = cat.rate >= 80 ? chalk.green : cat.rate >= 60 ? chalk.yellow : chalk.red;
+        const bar = "\u2588".repeat(Math.round(cat.rate / 5)) + "\u2591".repeat(20 - Math.round(cat.rate / 5));
+        console.log(`    ${cat.category.padEnd(15)} ${catColor(bar)} ${catColor(`${cat.rate}%`)} (${cat.total})`);
+      }
+    }
+  } else {
+    console.log(chalk.gray("  No practice events recorded yet."));
+    console.log(chalk.gray("  Call paradigm_habits_check via MCP to start recording.\n"));
+  }
+  console.log();
+}
+async function habitsInitCommand(options) {
+  const rootDir = process.cwd();
+  const configPath = path2.join(rootDir, HABITS_FILE);
+  if (fs2.existsSync(configPath) && !options.force) {
+    console.log(chalk.yellow(`${HABITS_FILE} already exists. Use --force to overwrite.`));
+    return;
+  }
+  const dir = path2.dirname(configPath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+  const defaultConfig = {
+    version: "1.0",
+    habits: [],
+    overrides: {
+      "verify-before-done": {
+        severity: "warn"
+      }
+    }
+  };
+  const content = `# Paradigm Habits Configuration
+# See: paradigm habits list (for all seed habits)
+#
+# Seed habits are built-in and active by default.
+# Use 'overrides' to tune severity or disable specific habits.
+# Add custom habits in the 'habits' section.
+
+${yaml2.dump(defaultConfig, { lineWidth: 80, noRefs: true })}
+# Example custom habit:
+# habits:
+#   - id: my-custom-check
+#     name: "Custom Check"
+#     description: "Describe what this habit enforces"
+#     category: verification
+#     trigger: postflight
+#     severity: advisory
+#     check:
+#       type: tool-called
+#       params:
+#         tools: [paradigm_pm_postflight]
+#     enabled: true
+#
+# Override seed habits:
+# overrides:
+#   verify-before-done:
+#     severity: block      # Upgrade to blocking
+#   check-fragility:
+#     enabled: false        # Disable this habit
+`;
+  fs2.writeFileSync(configPath, content, "utf8");
+  invalidateHabitsCache(rootDir);
+  console.log(chalk.green(`Created ${HABITS_FILE}`));
+  console.log(chalk.gray("  10 seed habits are active by default."));
+  console.log(chalk.gray("  Use overrides section to tune severity or disable habits."));
+  console.log(chalk.gray("  Run `paradigm habits list` to see all habits.\n"));
+}
+async function habitsAddCommand(options) {
+  const rootDir = process.cwd();
+  const configPath = path2.join(rootDir, HABITS_FILE);
+  if (!fs2.existsSync(configPath)) {
+    console.log(chalk.yellow(`No ${HABITS_FILE} found. Run 'paradigm habits init' first.`));
+    return;
+  }
+  let config;
+  try {
+    const content = fs2.readFileSync(configPath, "utf8");
+    config = yaml2.load(content);
+    if (!config.habits) config.habits = [];
+  } catch (err) {
+    console.log(chalk.red("Failed to parse habits.yaml:"), err.message);
+    return;
+  }
+  const existingIds = /* @__PURE__ */ new Set([
+    ...config.habits.map((h) => h.id),
+    ...loadHabits(rootDir).map((h) => h.id)
+  ]);
+  if (existingIds.has(options.id)) {
+    console.log(chalk.yellow(`Habit "${options.id}" already exists.`));
+    return;
+  }
+  const tools = options.tools ? options.tools.split(",").map((t) => t.trim()) : [];
+  const newHabit = {
+    id: options.id,
+    name: options.name,
+    description: options.description,
+    category: options.category,
+    trigger: options.trigger,
+    severity: options.severity || "advisory",
+    check: {
+      type: "tool-called",
+      params: { tools }
+    },
+    enabled: true
+  };
+  config.habits.push(newHabit);
+  fs2.writeFileSync(configPath, yaml2.dump(config, { lineWidth: 80, noRefs: true }), "utf8");
+  invalidateHabitsCache(rootDir);
+  console.log(chalk.green(`Added habit: ${options.id}`));
+  console.log(chalk.gray(`  Name: ${options.name}`));
+  console.log(chalk.gray(`  Category: ${options.category} | Trigger: ${options.trigger} | Severity: ${options.severity || "advisory"}`));
+  if (tools.length > 0) {
+    console.log(chalk.gray(`  Tools: ${tools.join(", ")}`));
+  }
+  console.log();
+}
+export {
+  habitsAddCommand,
+  habitsInitCommand,
+  habitsListCommand,
+  habitsStatusCommand
+};

package/dist/{hooks-7TQIRXXS.js → hooks-ZVGXLK6Z.js}

@@ -3,7 +3,7 @@ import {
   hooksInstallCommand,
   hooksStatusCommand,
   hooksUninstallCommand
-} from "./chunk-4WR7X3FE.js";
+} from "./chunk-LRSJNX7K.js";
 import "./chunk-MO4EEYFW.js";
 export {
   hooksInstallCommand,