@massu/core 0.6.3 → 0.7.0

package/dist/cli.js

@@ -125,7 +125,7 @@ function getResolvedPaths() {
     settingsLocalPath: resolve(root, claudeDirName, "settings.local.json")
   };
 }
-var DomainConfigSchema, PatternRuleConfigSchema, CostModelSchema, AnalyticsConfigSchema, CustomPatternSchema, GovernanceConfigSchema, SecurityPatternSchema, SecurityConfigSchema, TeamConfigSchema, RegressionConfigSchema, CloudConfigSchema, ConventionsConfigSchema, PythonDomainConfigSchema, PythonConfigSchema, PathsConfigSchema, RawConfigSchema, _config, _projectRoot;
+var DomainConfigSchema, PatternRuleConfigSchema, CostModelSchema, AnalyticsConfigSchema, CustomPatternSchema, GovernanceConfigSchema, SecurityPatternSchema, SecurityConfigSchema, TeamConfigSchema, RegressionConfigSchema, AutoLearningConfigSchema, CloudConfigSchema, ConventionsConfigSchema, PythonDomainConfigSchema, PythonConfigSchema, PathsConfigSchema, RawConfigSchema, _config, _projectRoot;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
@@ -248,6 +248,32 @@ var init_config = __esm({
         warning: z.number().default(50)
       }).optional()
     }).optional();
+    AutoLearningConfigSchema = z.object({
+      enabled: z.boolean().default(true),
+      incidentDir: z.string().default("docs/incidents"),
+      memoryDir: z.string().default("memory"),
+      memoryIndexFile: z.string().default("MEMORY.md"),
+      enforcementHooksDir: z.string().default("scripts/hooks"),
+      fixDetection: z.object({
+        enabled: z.boolean().default(true),
+        lookbackDays: z.number().default(7),
+        signals: z.array(z.string()).default([
+          "removed_broken_code",
+          "added_error_handling",
+          "method_name_correction",
+          "auth_fix",
+          "nil_handling_fix",
+          "concurrency_fix",
+          "async_pattern_fix",
+          "added_missing_import"
+        ])
+      }).default({}),
+      pipeline: z.object({
+        requireIncidentReport: z.boolean().default(true),
+        requirePreventionRule: z.boolean().default(true),
+        requireEnforcement: z.boolean().default(true)
+      }).default({})
+    }).optional();
     CloudConfigSchema = z.object({
       enabled: z.boolean().default(false),
       apiKey: z.string().optional(),
@@ -337,7 +363,8 @@ var init_config = __esm({
       regression: RegressionConfigSchema,
       cloud: CloudConfigSchema,
       conventions: ConventionsConfigSchema,
-      python: PythonConfigSchema
+      python: PythonConfigSchema,
+      autoLearning: AutoLearningConfigSchema
     }).passthrough();
     _config = null;
     _projectRoot = null;

package/dist/hooks/auto-learning-pipeline.js

@@ -0,0 +1,469 @@
+#!/usr/bin/env node
+import{createRequire as __cr}from"module";const require=__cr(import.meta.url);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/hooks/auto-learning-pipeline.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, unlinkSync, readdirSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// src/config.ts
+import { resolve, dirname } from "path";
+import { existsSync, readFileSync } from "fs";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+var DomainConfigSchema = z.object({
+  name: z.string().default("Unknown"),
+  routers: z.array(z.string()).default([]),
+  pages: z.array(z.string()).default([]),
+  tables: z.array(z.string()).default([]),
+  allowedImportsFrom: z.array(z.string()).default([])
+});
+var PatternRuleConfigSchema = z.object({
+  pattern: z.string().default("**"),
+  rules: z.array(z.string()).default([])
+});
+var CostModelSchema = z.object({
+  input_per_million: z.number(),
+  output_per_million: z.number(),
+  cache_read_per_million: z.number().optional(),
+  cache_write_per_million: z.number().optional()
+});
+var AnalyticsConfigSchema = z.object({
+  quality: z.object({
+    weights: z.record(z.string(), z.number()).default({
+      bug_found: -5,
+      vr_failure: -10,
+      incident: -20,
+      cr_violation: -3,
+      vr_pass: 2,
+      clean_commit: 5,
+      successful_verification: 3
+    }),
+    categories: z.array(z.string()).default(["security", "architecture", "coupling", "tests", "rule_compliance"])
+  }).optional(),
+  cost: z.object({
+    models: z.record(z.string(), CostModelSchema).default({}),
+    currency: z.string().default("USD")
+  }).optional(),
+  prompts: z.object({
+    success_indicators: z.array(z.string()).default(["committed", "approved", "looks good", "perfect", "great", "thanks"]),
+    failure_indicators: z.array(z.string()).default(["revert", "wrong", "that's not", "undo", "incorrect"]),
+    max_turns_for_success: z.number().default(2)
+  }).optional()
+}).optional();
+var CustomPatternSchema = z.object({
+  pattern: z.string(),
+  severity: z.string(),
+  message: z.string()
+});
+var GovernanceConfigSchema = z.object({
+  audit: z.object({
+    formats: z.array(z.string()).default(["summary", "detailed", "soc2"]),
+    retention_days: z.number().default(365),
+    auto_log: z.record(z.string(), z.boolean()).default({
+      code_changes: true,
+      rule_enforcement: true,
+      approvals: true,
+      commits: true
+    })
+  }).optional(),
+  validation: z.object({
+    realtime: z.boolean().default(true),
+    checks: z.record(z.string(), z.boolean()).default({
+      rule_compliance: true,
+      import_existence: true,
+      naming_conventions: true
+    }),
+    custom_patterns: z.array(CustomPatternSchema).default([])
+  }).optional(),
+  adr: z.object({
+    detection_phrases: z.array(z.string()).default(["chose", "decided", "switching to", "moving from", "going with"]),
+    template: z.string().default("default"),
+    storage: z.string().default("database"),
+    output_dir: z.string().default("docs/adr")
+  }).optional()
+}).optional();
+var SecurityPatternSchema = z.object({
+  pattern: z.string(),
+  severity: z.string(),
+  category: z.string(),
+  description: z.string()
+});
+var SecurityConfigSchema = z.object({
+  patterns: z.array(SecurityPatternSchema).default([]),
+  auto_score_on_edit: z.boolean().default(true),
+  score_threshold_alert: z.number().default(50),
+  severity_weights: z.record(z.string(), z.number()).optional(),
+  restrictive_licenses: z.array(z.string()).optional(),
+  dep_alternatives: z.record(z.string(), z.array(z.string())).optional(),
+  dependencies: z.object({
+    package_manager: z.string().default("npm"),
+    blocked_packages: z.array(z.string()).default([]),
+    preferred_packages: z.record(z.string(), z.string()).default({}),
+    max_bundle_size_kb: z.number().default(500)
+  }).optional()
+}).optional();
+var TeamConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  sync_backend: z.string().default("local"),
+  developer_id: z.string().default("auto"),
+  share_by_default: z.boolean().default(false),
+  expertise_weights: z.object({
+    session: z.number().default(20),
+    observation: z.number().default(10)
+  }).optional(),
+  privacy: z.object({
+    share_file_paths: z.boolean().default(true),
+    share_code_snippets: z.boolean().default(false),
+    share_observations: z.boolean().default(true)
+  }).optional()
+}).optional();
+var RegressionConfigSchema = z.object({
+  test_patterns: z.array(z.string()).default([
+    "{dir}/__tests__/{name}.test.{ext}",
+    "{dir}/{name}.spec.{ext}",
+    "tests/{path}.test.{ext}"
+  ]),
+  test_runner: z.string().default("npm test"),
+  health_thresholds: z.object({
+    healthy: z.number().default(80),
+    warning: z.number().default(50)
+  }).optional()
+}).optional();
+var AutoLearningConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  incidentDir: z.string().default("docs/incidents"),
+  memoryDir: z.string().default("memory"),
+  memoryIndexFile: z.string().default("MEMORY.md"),
+  enforcementHooksDir: z.string().default("scripts/hooks"),
+  fixDetection: z.object({
+    enabled: z.boolean().default(true),
+    lookbackDays: z.number().default(7),
+    signals: z.array(z.string()).default([
+      "removed_broken_code",
+      "added_error_handling",
+      "method_name_correction",
+      "auth_fix",
+      "nil_handling_fix",
+      "concurrency_fix",
+      "async_pattern_fix",
+      "added_missing_import"
+    ])
+  }).default({}),
+  pipeline: z.object({
+    requireIncidentReport: z.boolean().default(true),
+    requirePreventionRule: z.boolean().default(true),
+    requireEnforcement: z.boolean().default(true)
+  }).default({})
+}).optional();
+var CloudConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  apiKey: z.string().optional(),
+  endpoint: z.string().optional(),
+  sync: z.object({
+    memory: z.boolean().default(true),
+    analytics: z.boolean().default(true),
+    audit: z.boolean().default(true)
+  }).default({ memory: true, analytics: true, audit: true })
+}).optional();
+var ConventionsConfigSchema = z.object({
+  claudeDirName: z.string().default(".claude").refine(
+    (s) => !s.includes("..") && !s.startsWith("/"),
+    { message: 'claudeDirName must not contain ".." or start with "/"' }
+  ),
+  sessionStatePath: z.string().default(".claude/session-state/CURRENT.md").refine(
+    (s) => !s.includes("..") && !s.startsWith("/"),
+    { message: 'sessionStatePath must not contain ".." or start with "/"' }
+  ),
+  sessionArchivePath: z.string().default(".claude/session-state/archive").refine(
+    (s) => !s.includes("..") && !s.startsWith("/"),
+    { message: 'sessionArchivePath must not contain ".." or start with "/"' }
+  ),
+  knowledgeCategories: z.array(z.string()).default([
+    "patterns",
+    "commands",
+    "incidents",
+    "reference",
+    "protocols",
+    "checklists",
+    "playbooks",
+    "critical",
+    "scripts",
+    "status",
+    "templates",
+    "loop-state",
+    "session-state",
+    "agents"
+  ]),
+  knowledgeSourceFiles: z.array(z.string()).default(["CLAUDE.md", "MEMORY.md", "corrections.md"]),
+  excludePatterns: z.array(z.string()).default(["/ARCHIVE/", "/SESSION-HISTORY/"])
+}).optional();
+var PythonDomainConfigSchema = z.object({
+  name: z.string(),
+  packages: z.array(z.string()),
+  allowed_imports_from: z.array(z.string()).default([])
+});
+var PythonConfigSchema = z.object({
+  root: z.string(),
+  alembic_dir: z.string().optional(),
+  domains: z.array(PythonDomainConfigSchema).default([]),
+  exclude_dirs: z.array(z.string()).default(["__pycache__", ".venv", "venv", ".mypy_cache", ".pytest_cache"])
+}).optional();
+var PathsConfigSchema = z.object({
+  source: z.string().default("src"),
+  aliases: z.record(z.string(), z.string()).default({ "@": "src" }),
+  routers: z.string().optional(),
+  routerRoot: z.string().optional(),
+  pages: z.string().optional(),
+  middleware: z.string().optional(),
+  schema: z.string().optional(),
+  components: z.string().optional(),
+  hooks: z.string().optional()
+});
+var RawConfigSchema = z.object({
+  project: z.object({
+    name: z.string().default("my-project"),
+    root: z.string().default("auto")
+  }).default({ name: "my-project", root: "auto" }),
+  framework: z.object({
+    type: z.string().default("typescript"),
+    router: z.string().default("none"),
+    orm: z.string().default("none"),
+    ui: z.string().default("none")
+  }).default({ type: "typescript", router: "none", orm: "none", ui: "none" }),
+  paths: PathsConfigSchema.default({ source: "src", aliases: { "@": "src" } }),
+  toolPrefix: z.string().default("massu"),
+  dbAccessPattern: z.string().optional(),
+  knownMismatches: z.record(z.string(), z.record(z.string(), z.string())).optional(),
+  accessScopes: z.array(z.string()).optional(),
+  domains: z.array(DomainConfigSchema).default([]),
+  rules: z.array(PatternRuleConfigSchema).default([]),
+  analytics: AnalyticsConfigSchema,
+  governance: GovernanceConfigSchema,
+  security: SecurityConfigSchema,
+  team: TeamConfigSchema,
+  regression: RegressionConfigSchema,
+  cloud: CloudConfigSchema,
+  conventions: ConventionsConfigSchema,
+  python: PythonConfigSchema,
+  autoLearning: AutoLearningConfigSchema
+}).passthrough();
+var _config = null;
+var _projectRoot = null;
+function findProjectRoot() {
+  const cwd = process.cwd();
+  let dir = cwd;
+  while (true) {
+    if (existsSync(resolve(dir, "massu.config.yaml"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  dir = cwd;
+  while (true) {
+    if (existsSync(resolve(dir, "package.json"))) {
+      return dir;
+    }
+    if (existsSync(resolve(dir, ".git"))) {
+      return dir;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return cwd;
+}
+function getProjectRoot() {
+  if (!_projectRoot) {
+    _projectRoot = findProjectRoot();
+  }
+  return _projectRoot;
+}
+function getConfig() {
+  if (_config) return _config;
+  const root = getProjectRoot();
+  const configPath = resolve(root, "massu.config.yaml");
+  let rawYaml = {};
+  if (existsSync(configPath)) {
+    const content = readFileSync(configPath, "utf-8");
+    rawYaml = parseYaml(content) ?? {};
+  }
+  const parsed = RawConfigSchema.parse(rawYaml);
+  const projectRoot = parsed.project.root === "auto" || !parsed.project.root ? root : resolve(root, parsed.project.root);
+  _config = {
+    project: {
+      name: parsed.project.name,
+      root: projectRoot
+    },
+    framework: parsed.framework,
+    paths: parsed.paths,
+    toolPrefix: parsed.toolPrefix,
+    dbAccessPattern: parsed.dbAccessPattern,
+    knownMismatches: parsed.knownMismatches,
+    accessScopes: parsed.accessScopes,
+    domains: parsed.domains,
+    rules: parsed.rules,
+    analytics: parsed.analytics,
+    governance: parsed.governance,
+    security: parsed.security,
+    team: parsed.team,
+    regression: parsed.regression,
+    cloud: parsed.cloud,
+    conventions: parsed.conventions,
+    python: parsed.python
+  };
+  if (!_config.cloud?.apiKey && process.env.MASSU_API_KEY) {
+    _config.cloud = {
+      enabled: true,
+      sync: { memory: true, analytics: true, audit: true },
+      ..._config.cloud,
+      apiKey: process.env.MASSU_API_KEY
+    };
+  }
+  return _config;
+}
+
+// src/hooks/auto-learning-pipeline.ts
+function getSessionFlagPath(sessionId) {
+  return join(tmpdir(), "massu-auto-learning", `fixes-${sessionId.slice(0, 12)}.jsonl`);
+}
+async function main() {
+  try {
+    const input = await readStdin();
+    const hookInput = JSON.parse(input);
+    const config = getConfig();
+    if (config.autoLearning?.enabled === false) {
+      process.exit(0);
+      return;
+    }
+    const root = getProjectRoot();
+    const incidentDir = config.autoLearning?.incidentDir ?? "docs/incidents";
+    const memoryDir = config.autoLearning?.memoryDir ?? "memory";
+    const autoLearn = config.autoLearning;
+    const flagPath = getSessionFlagPath(hookInput.session_id);
+    let sessionFixes = [];
+    if (existsSync2(flagPath)) {
+      try {
+        sessionFixes = readFileSync2(flagPath, "utf-8").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+      } catch {
+      }
+    }
+    let uncommittedFix = false;
+    try {
+      const diff = execSync("git diff --name-only", { cwd: root, timeout: 3e3, encoding: "utf-8" });
+      if (diff.trim()) {
+        const fullDiff = execSync("git diff", { cwd: root, timeout: 5e3, encoding: "utf-8" });
+        const fixPatterns = (fullDiff.match(/^\+.*(try|except|catch|guard|@MainActor|asyncio\.timeout|X-Service-Token|\.save\(|return False)/gm) || []).length;
+        const removedBroken = (fullDiff.match(/^-.*(bug|broken|crash|\.store\(|= nil|error)/gm) || []).length;
+        if (fixPatterns > 3 || removedBroken > 1) {
+          uncommittedFix = true;
+        }
+      }
+    } catch {
+    }
+    if (sessionFixes.length === 0 && !uncommittedFix) {
+      cleanup(flagPath);
+      process.exit(0);
+      return;
+    }
+    const lines = [];
+    lines.push("");
+    lines.push("============================================================================");
+    lines.push(" MASSU AUTO-LEARNING PIPELINE \u2014 ACTION REQUIRED BEFORE SESSION END");
+    lines.push("============================================================================");
+    if (sessionFixes.length > 0) {
+      lines.push("");
+      lines.push(`  ${sessionFixes.length} bug fix(es) detected during this session:`);
+      lines.push("");
+      const byFile = /* @__PURE__ */ new Map();
+      for (const fix of sessionFixes) {
+        const existing = byFile.get(fix.file) ?? [];
+        existing.push(...fix.signals);
+        byFile.set(fix.file, [...new Set(existing)]);
+      }
+      for (const [file, signals] of byFile) {
+        lines.push(`    - ${file} (${signals.join(", ")})`);
+      }
+    }
+    if (uncommittedFix) {
+      lines.push("");
+      lines.push("  Additional uncommitted fix patterns detected in git diff.");
+    }
+    lines.push("");
+    lines.push("  Complete these steps before this session ends:");
+    lines.push("");
+    if (autoLearn?.pipeline?.requireIncidentReport !== false) {
+      lines.push("  STEP 1: INCIDENT REPORT");
+      lines.push(`    For each distinct bug fixed, create: ${incidentDir}/YYYY-MM-DD-<slug>.md`);
+      lines.push("    Include: Date, Severity, Symptoms, Root Cause, Fix, Files Changed, Prevention Rules");
+      lines.push("");
+    }
+    if (autoLearn?.pipeline?.requirePreventionRule !== false) {
+      lines.push("  STEP 2: PREVENTION RULE");
+      lines.push(`    For each incident, create: ${memoryDir}/feedback_<rule_name>.md`);
+      lines.push("    Include frontmatter (name, description, type: feedback) + Why + How to apply");
+      lines.push(`    Update ${config.autoLearning?.memoryIndexFile ?? "MEMORY.md"} index`);
+      lines.push("");
+    }
+    if (autoLearn?.pipeline?.requireEnforcement !== false) {
+      lines.push("  STEP 3: ENFORCEMENT PLACEMENT");
+      lines.push("    For each new rule, determine enforcement layer(s):");
+      lines.push("    a) If statically detectable \u2192 add to pattern-feedback hook");
+      lines.push("    b) If about editing certain files \u2192 add to blast-radius hook");
+      lines.push("    c) If about dangerous commands \u2192 add to dangerous-command hook");
+      lines.push("    d) If critical \u2192 add to pre-commit hook");
+      lines.push("    e) If needs runtime monitoring \u2192 create monitoring producer");
+      lines.push("");
+    }
+    lines.push("  STEP 4: VERIFY");
+    lines.push("    Test any new enforcement hooks to confirm they detect violations.");
+    lines.push("");
+    lines.push("============================================================================");
+    lines.push("");
+    console.log(lines.join("\n"));
+    cleanup(flagPath);
+  } catch {
+  }
+  process.exit(0);
+}
+function cleanup(flagPath) {
+  try {
+    if (existsSync2(flagPath)) unlinkSync(flagPath);
+    const dir = join(tmpdir(), "massu-auto-learning");
+    if (existsSync2(dir)) {
+      const now = Date.now();
+      for (const file of readdirSync(dir)) {
+        const fullPath = join(dir, file);
+        try {
+          const stat = __require("fs").statSync(fullPath);
+          if (now - stat.mtimeMs > 864e5) {
+            unlinkSync(fullPath);
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function readStdin() {
+  return new Promise((resolve2) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve2(data));
+    setTimeout(() => resolve2(data), 5e3);
+  });
+}
+main();

package/dist/hooks/cost-tracker.js

@@ -131,6 +131,32 @@ var RegressionConfigSchema = z.object({
     warning: z.number().default(50)
   }).optional()
 }).optional();
+var AutoLearningConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  incidentDir: z.string().default("docs/incidents"),
+  memoryDir: z.string().default("memory"),
+  memoryIndexFile: z.string().default("MEMORY.md"),
+  enforcementHooksDir: z.string().default("scripts/hooks"),
+  fixDetection: z.object({
+    enabled: z.boolean().default(true),
+    lookbackDays: z.number().default(7),
+    signals: z.array(z.string()).default([
+      "removed_broken_code",
+      "added_error_handling",
+      "method_name_correction",
+      "auth_fix",
+      "nil_handling_fix",
+      "concurrency_fix",
+      "async_pattern_fix",
+      "added_missing_import"
+    ])
+  }).default({}),
+  pipeline: z.object({
+    requireIncidentReport: z.boolean().default(true),
+    requirePreventionRule: z.boolean().default(true),
+    requireEnforcement: z.boolean().default(true)
+  }).default({})
+}).optional();
 var CloudConfigSchema = z.object({
   enabled: z.boolean().default(false),
   apiKey: z.string().optional(),
@@ -220,7 +246,8 @@ var RawConfigSchema = z.object({
   regression: RegressionConfigSchema,
   cloud: CloudConfigSchema,
   conventions: ConventionsConfigSchema,
-  python: PythonConfigSchema
+  python: PythonConfigSchema,
+  autoLearning: AutoLearningConfigSchema
 }).passthrough();
 var _config = null;
 var _projectRoot = null;