infernoflow 0.10.2 → 0.10.4

package/README.md

@@ -68,10 +68,17 @@ JSON-only output (clean machine output, no text logs):
 infernoflow init --adopt --yes --report-json-only
 ```
 
+Human-only output (visual report only, no JSON block):
+
+```bash
+infernoflow init --adopt --yes --report-human-only
+```
+
 What adoption creates:
 - `inferno/contract.json` (inferred capability baseline)
 - `inferno/capabilities.json` (inferred registry)
 - `inferno/scenarios/adoption_baseline.json` (coverage baseline)
+- `inferno/adoption_profile.json` (detected components, display fields, external libraries, UI layout, styling hints)
 - `inferno/CHANGELOG.md` (adoption entry)
 
 Safety:
@@ -155,6 +162,7 @@ infernoflow doc-gate --json
 infernoflow init --force       # overwrite existing files
 infernoflow init --yes         # skip prompts, use defaults
 infernoflow init --adopt       # infer baseline from existing project
+infernoflow init --adopt --report-human-only
 infernoflow suggest "..."      # describe what changed
 infernoflow implement "..." --mode both
 infernoflow implement "..." --mode cursor

package/bin/infernoflow.mjs

@@ -47,6 +47,7 @@ ${formatCommandsHelp()}
     --adopt             Infer capabilities from an existing codebase
     --report-json       Print inferred adoption report as JSON
     --report-json-only  Print JSON report only (no human-readable logs)
+    --report-human-only Print only human-readable adoption report (no JSON block)
     --yes, -y           Skip prompts and accept inferred/default values
     --force, -f         Overwrite existing inferno/ files
 

package/lib/commands/adopt.mjs

@@ -38,6 +38,10 @@ const HEURISTICS = [
 ];
 
 export function discoverCapabilities(cwd) {
+  return discoverProjectSignals(cwd).capabilities;
+}
+
+function collectCodeFiles(cwd) {
   const files = [];
   const roots = ["src", "server", "app", "backend", "frontend", "api"];
   for (const r of roots) {
@@ -51,13 +55,171 @@ export function discoverCapabilities(cwd) {
         if (entry.isDirectory()) {
           if (["node_modules", ".git", "dist", "build"].includes(entry.name)) continue;
           stack.push(p);
-        } else if (/\.(js|jsx|ts|tsx|mjs|cjs|json|md)$/.test(entry.name)) {
+        } else if (/\.(js|jsx|ts|tsx|mjs|cjs|json|md|html|htm)$/.test(entry.name)) {
           files.push(p);
         }
       }
     }
   }
+  return files;
+}
+
+function detectComponents(files, cwd) {
+  const names = new Set();
+  for (const filePath of files) {
+    const rel = path.relative(cwd, filePath);
+    const text = safeRead(filePath);
+    const classMatches = text.matchAll(/\bclass\s+([A-Z][A-Za-z0-9_]*?(?:Component|Page|View|Widget|Card))\b/g);
+    for (const m of classMatches) names.add(m[1]);
+    const selectorMatches = text.matchAll(/\bselector\s*:\s*["']([^"']+)["']/g);
+    for (const m of selectorMatches) names.add(m[1]);
+    const reactFnMatches = text.matchAll(/\bfunction\s+([A-Z][A-Za-z0-9_]*)\s*\(/g);
+    for (const m of reactFnMatches) {
+      if (/component|page|view|card|chart|dashboard/i.test(m[1])) names.add(m[1]);
+    }
+    const relMatch = rel.match(/([^/\\]+)\.(component|page|view|widget|card)\.(ts|tsx|js|jsx)$/i);
+    if (relMatch) names.add(relMatch[1]);
+  }
+  return Array.from(names).sort();
+}
+
+function detectDisplayFields(files) {
+  const fields = new Set();
+  const methodNames = new Set();
+  const stopWords = new Set([
+    "if", "for", "while", "const", "let", "var", "return", "function", "class", "import", "export",
+    "null", "undefined", "true", "false", "string", "number", "boolean", "any", "unknown", "never",
+    "selector", "templateUrl", "styleUrl", "standalone", "imports", "providers", "providedIn",
+    "options", "scales", "responsive", "display", "title", "type", "label",
+    "component", "service", "routes", "appConfig", "ApplicationConfig",
+  ]);
+  const add = (v) => {
+    if (!v) return;
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(v)) return;
+    if (v.length <= 1) return;
+    if (stopWords.has(v)) return;
+    if (/^[A-Z0-9_]+$/.test(v)) return;
+    fields.add(v);
+  };
+  for (const filePath of files) {
+    const text = safeRead(filePath);
+    if (/\.(html|htm)$/i.test(filePath)) {
+      const angularInterpolations = text.matchAll(/\{\{\s*(?:this\.)?([a-zA-Z_][a-zA-Z0-9_]*)/g);
+      for (const m of angularInterpolations) add(m[1]);
+      const ngModels = text.matchAll(/\[\(ngModel\)\]\s*=\s*["']([a-zA-Z_][a-zA-Z0-9_]*)["']/g);
+      for (const m of ngModels) add(m[1]);
+      const ngInputs = text.matchAll(/\[[a-zA-Z0-9_-]+\]\s*=\s*["'](?:this\.)?([a-zA-Z_][a-zA-Z0-9_]*)["']/g);
+      for (const m of ngInputs) add(m[1]);
+      const ngIfs = text.matchAll(/\*ngIf\s*=\s*["'](?:this\.)?([a-zA-Z_][a-zA-Z0-9_]*)/g);
+      for (const m of ngIfs) add(m[1]);
+    }
+    if (/\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(filePath)) {
+      const methodDecl = text.matchAll(
+        /(?:^|\n)\s*(?:public|private|protected)?\s*(?:async\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*\([^)]*\)\s*\{/g
+      );
+      for (const m of methodDecl) methodNames.add(m[1]);
+
+      const thisRefs = text.matchAll(/\bthis\.([a-zA-Z_][a-zA-Z0-9_]*)\b/g);
+      for (const m of thisRefs) add(m[1]);
+
+      const classProps = text.matchAll(
+        /(?:^|\n)\s*(?:public|private|protected)?\s*(?:readonly\s+)?([a-zA-Z_][a-zA-Z0-9_]*)\s*(?::|=)/g
+      );
+      for (const m of classProps) {
+        add(m[1]);
+      }
+
+      const inputProps = text.matchAll(/@Input\([^)]*\)\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*[:=]/g);
+      for (const m of inputProps) add(m[1]);
+
+      const forEachParams = text.matchAll(/forEach\(\((\w+)\)\s*=>/g);
+      for (const m of forEachParams) {
+        const item = m[1];
+        const propAccess = new RegExp(`\\b${item}\\.([a-zA-Z_][a-zA-Z0-9_]*)\\b`, "g");
+        for (const p of text.matchAll(propAccess)) add(p[1]);
+      }
+    }
+  }
+  return Array.from(fields)
+    .filter((name) => !methodNames.has(name))
+    .sort()
+    .slice(0, 80);
+}
+
+function detectExternalLibraries(cwd) {
+  const libs = new Set();
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) return [];
+  try {
+    const pkg = JSON.parse(safeRead(pkgPath) || "{}");
+    const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+    for (const name of Object.keys(deps)) libs.add(name);
+  } catch {}
+  return Array.from(libs).sort();
+}
+
+function detectStyling(cwd, files, externalLibraries) {
+  const styleFiles = files
+    .filter((f) => /\.(css|scss|sass|less|styl)$/i.test(f))
+    .map((f) => path.relative(cwd, f))
+    .sort();
+
+  const frameworks = [];
+  const hasDep = (name) => externalLibraries.includes(name);
+  if (hasDep("tailwindcss")) frameworks.push("Tailwind CSS");
+  if (hasDep("bootstrap")) frameworks.push("Bootstrap");
+  if (externalLibraries.some((lib) => lib.startsWith("@angular/material"))) frameworks.push("Angular Material");
+  if (hasDep("antd")) frameworks.push("Ant Design");
+  if (hasDep("styled-components")) frameworks.push("styled-components");
+  if (hasDep("emotion") || hasDep("@emotion/react")) frameworks.push("Emotion");
+
+  const tokenVars = new Set();
+  for (const filePath of files) {
+    if (!/\.(css|scss|sass|less|styl|html|htm|ts|tsx|js|jsx|mjs|cjs)$/i.test(filePath)) continue;
+    const text = safeRead(filePath);
+    for (const m of text.matchAll(/--([a-zA-Z][a-zA-Z0-9_-]*)/g)) tokenVars.add(`--${m[1]}`);
+  }
+
+  return {
+    cssFrameworks: frameworks,
+    styleFileCount: styleFiles.length,
+    styleFilesSample: styleFiles.slice(0, 12),
+    designTokens: Array.from(tokenVars).sort().slice(0, 24),
+  };
+}
+
+function detectUiLayout(files) {
+  let usesGrid = false;
+  let usesFlex = false;
+  const sections = new Set();
+
+  for (const filePath of files) {
+    if (!/\.(html|htm|tsx|jsx|ts|js|mjs|cjs)$/i.test(filePath)) continue;
+    const text = safeRead(filePath);
+
+    if (/\bgrid\b|grid-template|grid-cols-|display:\s*grid/i.test(text)) usesGrid = true;
+    if (/\bflex\b|display:\s*flex|flex-row|flex-col|justify-|items-/i.test(text)) usesFlex = true;
+
+    for (const m of text.matchAll(/<(main|header|footer|section|aside|nav)\b/gi)) {
+      sections.add(m[1].toLowerCase());
+    }
+    for (const m of text.matchAll(/class(?:Name)?\s*=\s*["'`][^"'`]*(dashboard|chart|card|sidebar|content|toolbar|filter|panel|table)[^"'`]*["'`]/gi)) {
+      const hit = m[1].toLowerCase();
+      sections.add(hit === "filter" ? "filters" : hit);
+    }
+  }
+
+  const layoutType = usesGrid && usesFlex ? "mixed" : usesGrid ? "grid" : usesFlex ? "flex" : "unknown";
+  return {
+    layoutType,
+    usesGrid,
+    usesFlex,
+    sections: Array.from(sections).sort(),
+  };
+}
 
+export function discoverProjectSignals(cwd) {
+  const files = collectCodeFiles(cwd);
   const inferred = new Map();
   const addHit = (cap, filePath) => {
     if (!inferred.has(cap.id)) {
@@ -96,10 +258,19 @@ export function discoverCapabilities(cwd) {
     inferred.set("ReadItems", { id: "ReadItems", title: "Read Items", reason: "Fallback default", sourceFiles: new Set() });
   }
 
-  return Array.from(inferred.values()).map((c) => ({
+  const capabilities = Array.from(inferred.values()).map((c) => ({
     ...c,
     sourceFiles: Array.from(c.sourceFiles || []),
   }));
+  const externalLibraries = detectExternalLibraries(cwd);
+  return {
+    capabilities,
+    components: detectComponents(files, cwd),
+    displayFields: detectDisplayFields(files),
+    externalLibraries,
+    uiLayout: detectUiLayout(files),
+    styling: detectStyling(cwd, files, externalLibraries),
+  };
 }
 
 export async function reviewCapabilitiesInteractive(capabilities, yes = false) {
@@ -122,19 +293,83 @@ export async function reviewCapabilitiesInteractive(capabilities, yes = false) {
 
 export function buildAdoptionReport(capabilities) {
   if (!capabilities.length) return "No capabilities inferred.";
-  const lines = ["Inferred capabilities report:"];
-  for (const c of summarizeCapabilities(capabilities)) {
-    lines.push(`- ${c.id} (${c.title})  [confidence: ${c.confidence}]`);
+  const summarized = summarizeCapabilities(capabilities);
+  const totalSignals = summarized.reduce((acc, c) => acc + c.signalCount, 0);
+  const byConfidence = {
+    high: summarized.filter((c) => c.confidence === "high").length,
+    medium: summarized.filter((c) => c.confidence === "medium").length,
+    low: summarized.filter((c) => c.confidence === "low").length,
+  };
+
+  const lines = [];
+  lines.push("Adoption Analysis");
+  lines.push("=".repeat(56));
+  lines.push(`Capabilities detected : ${summarized.length}`);
+  lines.push(`Signal hits total     : ${totalSignals}`);
+  lines.push(
+    `Confidence mix        : high=${byConfidence.high}, medium=${byConfidence.medium}, low=${byConfidence.low}`
+  );
+  lines.push("-".repeat(56));
+  lines.push("Capability Breakdown");
+  lines.push("-".repeat(56));
+  lines.push("Confidence  Signals  Capability");
+  lines.push("-".repeat(56));
+  for (const c of summarized) {
+    const confidence = c.confidence.toUpperCase().padEnd(10, " ");
+    const signals = String(c.signalCount).padEnd(7, " ");
+    lines.push(`${confidence}  ${signals}  ${c.id} (${c.title})`);
     if (c.signalCount > 0) {
       const sample = c.sourceFiles.slice(0, 3).join(", ");
       lines.push(`  sources: ${sample}`);
+      if (c.sourceFiles.length > 3) {
+        lines.push(`  more   : +${c.sourceFiles.length - 3} additional files`);
+      }
     } else {
-      lines.push(`  sources: inferred fallback (no strong code signal)`);
+      lines.push("  sources: inferred fallback (no strong code signal)");
     }
   }
+  lines.push("=".repeat(56));
   return lines.join("\n");
 }
 
+export function buildSignalsReport(signals) {
+  const formatList = (title, items, limit = 10) => {
+    const lines = [`${title} (${items.length})`];
+    lines.push("-".repeat(56));
+    if (!items.length) {
+      lines.push("  - none");
+      return lines.join("\n");
+    }
+    for (const item of items.slice(0, limit)) {
+      lines.push(`  - ${item}`);
+    }
+    if (items.length > limit) {
+      lines.push(`  - ... +${items.length - limit} more`);
+    }
+    return lines.join("\n");
+  };
+
+  return [
+    "Project Structure Signals",
+    "=".repeat(56),
+    formatList("Components", signals.components || []),
+    formatList("Display fields", signals.displayFields || []),
+    formatList("External libraries", signals.externalLibraries || []),
+    "UI layout",
+    "-".repeat(56),
+    `  - layout type: ${signals.uiLayout?.layoutType || "unknown"}`,
+    `  - uses grid : ${signals.uiLayout?.usesGrid ? "yes" : "no"}`,
+    `  - uses flex : ${signals.uiLayout?.usesFlex ? "yes" : "no"}`,
+    `  - sections  : ${(signals.uiLayout?.sections || []).slice(0, 10).join(", ") || "none"}`,
+    "Styling",
+    "-".repeat(56),
+    `  - frameworks : ${(signals.styling?.cssFrameworks || []).join(", ") || "none detected"}`,
+    `  - style files: ${signals.styling?.styleFileCount ?? 0}`,
+    `  - tokens     : ${(signals.styling?.designTokens || []).slice(0, 8).join(", ") || "none detected"}`,
+    "=".repeat(56),
+  ].join("\n");
+}
+
 export function summarizeCapabilities(capabilities) {
   return capabilities.map((c) => {
     const hits = c.sourceFiles?.length || 0;
@@ -150,7 +385,7 @@ export function summarizeCapabilities(capabilities) {
   });
 }
 
-export function writeAdoptionBaseline(infernoDir, policyId, capabilities) {
+export function writeAdoptionBaseline(infernoDir, policyId, capabilities, signals = null) {
   const capIds = capabilities.map((c) => c.id);
   const contract = {
     policyId,
@@ -179,11 +414,25 @@ export function writeAdoptionBaseline(infernoDir, policyId, capabilities) {
   };
   fs.writeFileSync(path.join(infernoDir, "scenarios", "adoption_baseline.json"), JSON.stringify(scenario, null, 2) + "\n");
 
+  if (signals) {
+    const profile = {
+      profileId: "adoption_profile",
+      generatedAt: new Date().toISOString(),
+      components: signals.components || [],
+      displayFields: signals.displayFields || [],
+      externalLibraries: signals.externalLibraries || [],
+      uiLayout: signals.uiLayout || { layoutType: "unknown", usesGrid: false, usesFlex: false, sections: [] },
+      styling: signals.styling || { cssFrameworks: [], styleFileCount: 0, styleFilesSample: [], designTokens: [] },
+    };
+    fs.writeFileSync(path.join(infernoDir, "adoption_profile.json"), JSON.stringify(profile, null, 2) + "\n");
+  }
+
   const changelog = `# Changelog — ${policyId}
 
 ## Unreleased
 
 - Adopted infernoflow into an existing project and generated baseline capabilities.
+- Captured detected components, display fields, and external libraries in adoption profile.
 
 ## 0.1.0 — Adoption baseline
 

package/lib/commands/init.mjs

@@ -3,7 +3,14 @@ import * as path from "node:path";
 import * as readline from "node:readline";
 import { fileURLToPath } from "node:url";
 import { header, ok, warn, done, nextSteps, cyan, yellow, gray } from "../ui/output.mjs";
-import { discoverCapabilities, reviewCapabilitiesInteractive, writeAdoptionBaseline, buildAdoptionReport, summarizeCapabilities } from "./adopt.mjs";
+import {
+  discoverProjectSignals,
+  reviewCapabilitiesInteractive,
+  writeAdoptionBaseline,
+  buildAdoptionReport,
+  summarizeCapabilities,
+  buildSignalsReport,
+} from "./adopt.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -136,14 +143,21 @@ export async function initCommand(args) {
   const adopt = args.includes("--adopt");
   const reportJson = args.includes("--report-json");
   const reportJsonOnly = args.includes("--report-json-only");
+  const reportHumanOnly = args.includes("--report-human-only");
+  const silent = reportJsonOnly;
 
-  if (!reportJsonOnly) {
+  if (reportJsonOnly && reportHumanOnly) {
+    console.error("Error: --report-json-only and --report-human-only cannot be used together.");
+    process.exit(1);
+  }
+
+  if (!silent) {
     header("init");
   }
 
   const infernoDir = path.join(cwd, "inferno");
   if (fs.existsSync(infernoDir) && !force) {
-    if (reportJsonOnly) {
+    if (silent) {
       console.log(JSON.stringify({ ok: false, error: "inferno_exists", hint: "Use --force to overwrite" }, null, 2));
       process.exit(1);
     }
@@ -159,12 +173,22 @@ export async function initCommand(args) {
   let capabilities = defaultCaps.split(",").map(c => c.trim());
 
   if (adopt) {
-    const inferred = discoverCapabilities(cwd);
+    const signals = discoverProjectSignals(cwd);
+    const inferred = signals.capabilities;
     const summarized = summarizeCapabilities(inferred);
     if (reportJsonOnly) {
       console.log(
         JSON.stringify(
-          { mode: "adopt", policyId: detectedName, inferredCapabilities: summarized },
+          {
+            mode: "adopt",
+            policyId: detectedName,
+            inferredCapabilities: summarized,
+            components: signals.components,
+            displayFields: signals.displayFields,
+            externalLibraries: signals.externalLibraries,
+            uiLayout: signals.uiLayout,
+            styling: signals.styling,
+          },
           null,
           2
         )
@@ -173,13 +197,20 @@ export async function initCommand(args) {
       console.log();
       console.log(gray(buildAdoptionReport(inferred)));
       console.log();
-      if (reportJson) {
+      console.log(gray(buildSignalsReport(signals)));
+      console.log();
+      if (reportJson && !reportHumanOnly) {
         console.log(
           JSON.stringify(
             {
               mode: "adopt",
               policyId: detectedName,
               inferredCapabilities: summarized,
+              components: signals.components,
+              displayFields: signals.displayFields,
+              externalLibraries: signals.externalLibraries,
+              uiLayout: signals.uiLayout,
+              styling: signals.styling,
             },
             null,
             2
@@ -209,36 +240,38 @@ export async function initCommand(args) {
       id,
       title: id.replace(/([A-Z])/g, " $1").trim(),
     }));
-    writeAdoptionBaseline(infernoDir, policyId, capDetails);
-    if (!reportJsonOnly) {
+    const signals = discoverProjectSignals(cwd);
+    writeAdoptionBaseline(infernoDir, policyId, capDetails, signals);
+    if (!silent) {
       ok("Created: " + cyan("inferno/contract.json"));
       ok("Created: " + cyan("inferno/capabilities.json"));
       ok("Created: " + cyan("inferno/scenarios/adoption_baseline.json"));
+      ok("Created: " + cyan("inferno/adoption_profile.json"));
       ok("Created: " + cyan("inferno/CHANGELOG.md"));
     }
   } else {
     writeContract(path.join(infernoDir, "contract.json"), policyId, capabilities);
-    if (!reportJsonOnly) ok("Created: " + cyan("inferno/contract.json"));
+    if (!silent) ok("Created: " + cyan("inferno/contract.json"));
 
     writeCapabilities(path.join(infernoDir, "capabilities.json"), capabilities);
-    if (!reportJsonOnly) ok("Created: " + cyan("inferno/capabilities.json"));
+    if (!silent) ok("Created: " + cyan("inferno/capabilities.json"));
 
     writeScenario(path.join(infernoDir, "scenarios"), capabilities);
-    if (!reportJsonOnly) ok("Created: " + cyan("inferno/scenarios/happy_path.json"));
+    if (!silent) ok("Created: " + cyan("inferno/scenarios/happy_path.json"));
 
     writeChangelog(path.join(infernoDir, "CHANGELOG.md"), policyId);
-    if (!reportJsonOnly) ok("Created: " + cyan("inferno/CHANGELOG.md"));
+    if (!silent) ok("Created: " + cyan("inferno/CHANGELOG.md"));
   }
 
   // Copy doc-gate script
   const templates = getTemplatesRoot();
   const srcScript = path.join(templates, "scripts", "inferno-doc-gate.mjs");
   const dstScript = path.join(cwd, "scripts", "inferno-doc-gate.mjs");
-  copyFile(srcScript, dstScript, force, reportJsonOnly);
+  copyFile(srcScript, dstScript, force, silent);
 
-  upsertScripts(cwd, reportJsonOnly);
+  upsertScripts(cwd, silent);
 
-  if (!reportJsonOnly) {
+  if (!silent) {
     done("infernoflow initialized!");
 
     nextSteps([

package/package.json

@@ -1,43 +1,43 @@
-{
-  "name": "infernoflow",
-  "version": "0.10.2",
-  "description": "The forge for liquid code — keep capabilities, contracts, and docs in sync.",
-  "type": "module",
-  "bin": {
-    "infernoflow": "bin/infernoflow.mjs"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "files": [
-    "bin",
-    "lib",
-    "templates",
-    "README.md"
-  ],
-  "scripts": {
-    "test": "node scripts/smoke.mjs && node scripts/json-smoke.mjs && node scripts/json-negative-smoke.mjs && node scripts/implement-smoke.mjs",
-    "test:help": "node bin/infernoflow.mjs --help"
-  },
-  "keywords": [
-    "cli",
-    "capabilities",
-    "contract",
-    "documentation",
-    "ai",
-    "liquid-code",
-    "dx",
-    "developer-tools"
-  ],
-  "author": "infernoflow",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ronmiz/infernoflow.git"
-  },
-  "homepage": "https://github.com/ronmiz/infernoflow#readme",
-  "bugs": {
-    "url": "https://github.com/ronmiz/infernoflow/issues"
-  },
-  "dependencies": {}
-}
+{
+  "name": "infernoflow",
+  "version": "0.10.4",
+  "description": "The forge for liquid code — keep capabilities, contracts, and docs in sync.",
+  "type": "module",
+  "bin": {
+    "infernoflow": "bin/infernoflow.mjs"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "templates",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node scripts/smoke.mjs && node scripts/json-smoke.mjs && node scripts/json-negative-smoke.mjs && node scripts/implement-smoke.mjs",
+    "test:help": "node bin/infernoflow.mjs --help"
+  },
+  "keywords": [
+    "cli",
+    "capabilities",
+    "contract",
+    "documentation",
+    "ai",
+    "liquid-code",
+    "dx",
+    "developer-tools"
+  ],
+  "author": "infernoflow",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ronmiz/infernoflow.git"
+  },
+  "homepage": "https://github.com/ronmiz/infernoflow#readme",
+  "bugs": {
+    "url": "https://github.com/ronmiz/infernoflow/issues"
+  },
+  "dependencies": {}
+}