leancode 1.1.0

package/bin/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+const init = require("../cli/init.command");
+const sync = require("../cli/sync.command");
+
+const command = process.argv[2];
+
+switch (command) {
+  case "init":
+    init();
+    break;
+  case "sync":
+    sync();
+    break;
+  default:
+    console.log(`
+LeanCode CLI
+
+Commands:
+  leancode init   Initialize LeanCode
+  leancode sync   Refresh AI context
+`);
+}

package/cli/init.command.js

@@ -0,0 +1,14 @@
+
+const { generateLeanCode } = require("../generators/leancode.generator");
+const { scanRepository } = require("../engine/repo.scanner");
+
+module.exports = function init() {
+  console.log("⚡ Initializing LeanCode...");
+
+  const root = process.cwd();
+
+  generateLeanCode(root);
+  scanRepository(root);
+  // seedArchitecture(root); // Removed to prevent architecture.json creation
+  console.log(" LeanCode ready with AI context");
+};

package/cli/sync.command.js

@@ -0,0 +1,10 @@
+const { scanRepository } = require("../engine/repo.scanner");
+
+module.exports = function sync() {
+  console.log(" Syncing AI context...");
+
+  const root = process.cwd();
+  scanRepository(root);
+  console.log(" Calculating bloat score...");
+  console.log(" AI context updated");
+};

package/engine/architecture.loader.js

@@ -0,0 +1,12 @@
+const fs = require("fs");
+const path = require("path");
+
+function loadArchitecture(root) {
+  const file = path.join(root, ".leancode/architecture.json");
+
+  if (!fs.existsSync(file)) return null;
+
+  return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+
+module.exports = { loadArchitecture };

package/engine/architecture.seeder.js

@@ -0,0 +1,30 @@
+const fs = require("fs");
+const path = require("path");
+
+async function seedArchitecture(root) {
+  const dir = path.join(root, ".leancode");
+
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+
+  const configPath = path.join(dir, "architecture.json");
+
+  if (fs.existsSync(configPath)) return;
+
+  const architecture = {
+    version: 1,
+    mode: "learning",
+    structure: "auto",
+    rules: {
+      maxDepth: 3,
+      allowUtilsSprawl: false,
+      enforceDomains: false
+    },
+    domains: []
+  };
+
+  fs.writeFileSync(configPath, JSON.stringify(architecture, null, 2));
+}
+
+// module.exports = { seedArchitecture }; // Disabled to prevent architecture.json creation

package/engine/bloat.analyzer.js

@@ -0,0 +1,71 @@
+const fs = require("fs");
+const path = require("path");
+const { loadArchitecture } = require("./architecture.loader");
+
+
+const IGNORE = ["node_modules", ".git", ".leancode"];
+
+
+function analyzeBloat(root, issues = []) {
+  let fileCount = 0;
+  let smallFiles = 0;
+  let maxDepth = 0;
+  let duplicateNames = {};
+  let duplicates = 0;
+
+  function walk(dir, depth = 0) {
+    maxDepth = Math.max(maxDepth, depth);
+
+    const files = fs.readdirSync(dir);
+
+    files.forEach((file) => {
+      if (IGNORE.includes(file)) return;
+
+      const full = path.join(dir, file);
+      const stat = fs.statSync(full);
+
+      if (stat.isDirectory()) {
+        walk(full, depth + 1);
+      } else {
+        fileCount++;
+
+        if (stat.size < 300) smallFiles++;
+
+        duplicateNames[file] =
+          (duplicateNames[file] || 0) + 1;
+      }
+    });
+  }
+
+  walk(root);
+
+  Object.values(duplicateNames).forEach((count) => {
+    if (count > 1) duplicates += count - 1;
+  });
+
+  // ---- Metrics ----
+
+  const smallFileRatio = smallFiles / (fileCount || 1);
+  const depthScore = Math.min(maxDepth / 10, 1);
+  const duplicateScore = duplicates / (fileCount || 1);
+  const densityScore = Math.min(fileCount / 150, 1);
+
+  const finalScore =
+    (smallFileRatio +
+      depthScore +
+      duplicateScore +
+      densityScore) /
+    4;
+
+  return {
+    score: Math.round(finalScore * 100),
+    stats: {
+      fileCount,
+      smallFiles,
+      maxDepth,
+      duplicates,
+    },
+  };
+}
+
+module.exports = { analyzeBloat };

package/engine/drift.detector.js

@@ -0,0 +1,20 @@
+function detectDrift(files, architecture) {
+  const warnings = [];
+
+  const featureFolders = new Set(
+    files.map(f => f.split("/")[1])
+  );
+
+  featureFolders.forEach(folder => {
+    if (!architecture.domains.includes(folder)) {
+      warnings.push({
+        type: "drift",
+        message: `New domain emerging: ${folder}`
+      });
+    }
+  });
+
+  return warnings;
+}
+
+module.exports = { detectDrift };

package/engine/repo.scanner.js

@@ -0,0 +1,65 @@
+const fs = require("fs");
+const path = require("path");
+const { buildTree } = require("../utils/tree.utils");
+const { analyzeBloat } = require("./bloat.analyzer");
+const { loadArchitecture } = require("./architecture.loader");
+const { validateStructure } = require("./structure.guardian");
+
+
+
+function scanRepository(root) {
+  const lcDir = path.join(root, ".leancode");
+
+  if (!fs.existsSync(lcDir)) {
+    console.log(" LeanCode not initialized");
+    return;
+  }
+
+  const tree = buildTree(root);
+  const bloat = analyzeBloat(root);
+  const architecture = loadArchitecture(root);
+  const summary = `
+## Repository Structure (Auto Generated)
+
+\`\`\`
+${tree}
+\`\`\`
+
+## Code Bloat Analysis
+
+Bloat Score: **${bloat.score}%**
+
+### Metrics
+- Files: ${bloat.stats.fileCount}
+- Small Files: ${bloat.stats.smallFiles}
+- Max Depth: ${bloat.stats.maxDepth}
+- Duplicate Names: ${bloat.stats.duplicates}
+
+### Interpretation
+${
+  bloat.score < 30
+    ? "✅ Lean architecture"
+    : bloat.score < 60
+    ? "⚠️ Moderate complexity"
+    : "🚨 High code bloat detected"
+}
+
+### AI Optimization Instructions
+- Prefer modifying existing modules
+- Reduce file fragmentation
+- Merge tiny utilities when possible
+`;
+  
+  const baseTemplate = fs.readFileSync(
+    path.join(__dirname, "..", "templates", "AI_CONTEXT.base.md"),
+    "utf8"
+  );
+
+  fs.writeFileSync(
+    path.join(lcDir, "AI_CONTEXT.md"),
+    baseTemplate + summary
+    
+  );
+}
+
+module.exports = { scanRepository };

package/engine/structure.guardian.js

@@ -0,0 +1,27 @@
+
+function validateStructure(filePath, architecture) {
+  const warnings = [];
+
+  if (!architecture) return warnings;
+
+  // Rule 1: utils folder warning
+  if (filePath.includes("/utils/")) {
+    warnings.push({
+      type: "architecture",
+      message: "Utils folder detected — consider domain placement"
+    });
+  }
+
+  // Rule 2: deep nesting
+  const depth = filePath.split("/").length;
+  if (depth > architecture.rules.maxDepth + 3) {
+    warnings.push({
+      type: "architecture",
+      message: "File nesting too deep"
+    });
+  }
+
+  return warnings;
+}
+
+module.exports = { validateStructure };

package/generators/leancode.generator.js

@@ -0,0 +1,35 @@
+const fs = require("fs");
+const path = require("path");
+const { copyTemplate } = require("../utils/file.utils");
+
+function generateLeanCode(root) {
+  const lcDir = path.join(root, ".leancode");
+
+  // create .leancode folder
+  if (!fs.existsSync(lcDir)) {
+    fs.mkdirSync(lcDir);
+  }
+
+  const templates = path.join(__dirname, "..", "templates");
+
+  // ---- create internal rule files ----
+  copyTemplate(
+    path.join(templates, "ARCHITECTURE.md"),
+    path.join(lcDir, "ARCHITECTURE.md")
+  );
+
+  copyTemplate(
+    path.join(templates, "RULES.md"),
+    path.join(lcDir, "RULES.md")
+  );
+
+  // ---- create ROOT AI ENTRY FILE ---- ⭐ NEW
+  copyTemplate(
+    path.join(templates, "LEANCODE.md"),
+    path.join(root, "LEANCODE.md")
+  );
+
+  console.log("📁 LeanCode files created");
+}
+
+module.exports = { generateLeanCode };

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "leancode",
+  "version": "1.1.0",
+  "description": "LeanCode - AI anti code bloat framework",
+  "bin": {
+    "leancode": "./bin/index.js"
+  },
+  "type": "commonjs",
+  "license": "MIT"
+}

package/templates/AI_CONTEXT.base.md

@@ -0,0 +1,5 @@
+# LeanCode AI Context
+
+This repository uses LeanCode anti-bloat framework.
+
+AI must analyze project structure before generating code.

package/templates/ARCHITECTURE.md

@@ -0,0 +1,5 @@
+# Architecture Guidelines
+
+- Prefer reuse over creation
+- Maintain shallow folder depth
+- Single responsibility modules

package/templates/LEANCODE.md

@@ -0,0 +1,21 @@
+# LeanCode Enabled Repository
+
+This repository uses the LeanCode framework to reduce code bloat
+and maintain clean architecture.
+
+## Instructions for AI Assistants
+
+Before generating or modifying code, ALWAYS follow:
+
+- `.leancode/AI_CONTEXT.md`
+- `.leancode/ARCHITECTURE.md`
+- `.leancode/RULES.md`
+
+## Core Principles
+
+- Prefer modifying existing files over creating new ones
+- Avoid duplicate logic
+- Maintain minimal architecture
+- Respect current project structure
+
+LeanCode ensures AI-generated code remains lean and maintainable.

package/templates/RULES.md

@@ -0,0 +1,7 @@
+# LeanCode Rules
+
+AI must:
+
+- Modify existing files first
+- Avoid duplicate logic
+- Reduce unnecessary abstractions

package/utils/file.utils.js

@@ -0,0 +1,10 @@
+const fs = require("fs");
+
+function copyTemplate(src, dest) {
+  if (fs.existsSync(dest)) return;
+
+  const content = fs.readFileSync(src, "utf8");
+  fs.writeFileSync(dest, content);
+}
+
+module.exports = { copyTemplate };

package/utils/tree.utils.js

@@ -0,0 +1,30 @@
+const fs = require("fs");
+const path = require("path");
+
+const IGNORE = ["node_modules", ".git", ".leancode"];
+
+function buildTree(dir, prefix = "") {
+  let output = "";
+
+  const files = fs.readdirSync(dir);
+
+  files.forEach((file, index) => {
+    if (IGNORE.includes(file)) return;
+
+    const full = path.join(dir, file);
+    const isLast = index === files.length - 1;
+
+    output += `${prefix}${isLast ? "└──" : "├──"} ${file}\n`;
+
+    if (fs.statSync(full).isDirectory()) {
+      output += buildTree(
+        full,
+        prefix + (isLast ? "    " : "│   ")
+      );
+    }
+  });
+
+  return output;
+}
+
+module.exports = { buildTree };