@ionify/ionify 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Khaled Salem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,205 @@
+# ⚡ Ionify
+
+**A web infrastructure intelligence engine**
+
+Ionify unifies development and production workflows into one persistent pipeline: dependency graph + content-addressable cache + hybrid transforms + analysis-ready architecture.
+
+---
+
+## What is Ionify?
+
+Ionify is a web infrastructure intelligence engine.
+
+Instead of treating development and production as separate tools, Ionify runs the entire lifecycle through a single persistent engine — from file watching and resolution to transformation, caching, and bundling.
+
+At its core, Ionify maintains a **long-lived dependency graph** and a **content-addressable cache** that survive across runs. This allows the engine to understand how projects evolve over time, not just how they build once.
+
+Ionify combines a high-performance native core with a hybrid transformation strategy:
+- **OXC** as the primary engine for parsing and transformation
+- **SWC** as a fallback to ensure compatibility and resilience
+
+This unified and persistent design enables something traditional tooling cannot:  
+**infrastructure-level insight into the build process itself** — opening the door to analysis, optimization, and future AI-assisted recommendations.
+
+---
+
+## Why This Matters
+
+### What Ionify Unifies
+
+Ionify unifies what is traditionally fragmented across multiple tools:
+
+- Development server and production bundling
+- Resolution logic and dependency semantics
+- Transformation and caching strategies
+- Performance characteristics across environments
+
+By running everything through the same engine, Ionify eliminates an entire class of inconsistencies that appear when dev and build pipelines diverge.
+
+### For Developers
+
+- **Fewer "works in dev, breaks in build" surprises** — same pipeline in both modes
+- **Faster iteration** — persistent graph and cache reuse across runs
+- **Deterministic behavior** — consistent across environments
+- **Foundation for intelligent tooling** — infrastructure that can reason about builds, not just execute them
+
+Ionify is designed to be the layer *below* frameworks and plugins — the infrastructure they can rely on.
+
+---
+
+## Architecture
+
+### Pipeline Overview
+
+```
+Source Files
+    ↓
+  Resolver
+    ↓
+Persistent Dependency Graph (native)
+    ↓
+Transform Engine (OXC/SWC hybrid)
+    ↓
+Content-Addressable Store (.ionify/cas/versionHash/moduleHash/...)
+    ↓
+Dev Server / Bundler
+```
+
+### Hybrid Transformation Engine
+
+Ionify uses a hybrid transformation strategy by design.
+
+**OXC** is used as the primary engine for parsing and transformation, optimized for performance and modern JavaScript syntax. **SWC** acts as a fallback layer to ensure robustness and compatibility across edge cases and evolving ecosystems.
+
+This approach allows Ionify to remain framework-agnostic while balancing speed, correctness, and long-term maintainability.
+
+### Storage
+
+- **Graph persistence** — native Rust implementation
+- **Transformed outputs** — stored in version-isolated CAS
+- **Automatic invalidation** — via configuration hash
+
+### Why This Enables Intelligence
+
+Because Ionify persists the dependency graph and transformed outputs, the engine can observe patterns over time:
+- Which modules change frequently
+- Which transformations are expensive
+- How dependency structure affects rebuild cost
+
+This data is the basis for future analyzer tooling and AI-assisted optimization.
+
+---
+
+## Quick Start
+
+### Installation
+
+```bash
+pnpm add -D ionify
+```
+
+### Minimal Configuration
+
+Create `ionify.config.ts`:
+
+```typescript
+export default {
+  entry: "/src/main.ts",
+  outDir: "dist",
+};
+```
+
+### Development Server
+
+```bash
+pnpm ionify dev
+```
+
+### Production Build
+
+```bash
+pnpm ionify build
+```
+
+---
+
+## Project Status
+
+**Core engine:** Stable and production-ready  
+**Unified dev + build pipeline:** Implemented  
+**Persistent graph and CAS:** In place  
+**Dependency pipeline:** Stabilization in progress  
+**Plugin system:** Temporarily paused  
+**Analyzer and AI layers:** Planned on top of the unified engine
+
+---
+
+## Key Features
+
+### Current
+
+- **Persistent Graph Engine** — dependency graph saved to disk and reused across runs
+- **Unified Pipeline** — dev and production share the same core logic
+- **Content Addressable Cache (CAS)** — version-isolated, deterministic caching
+- **Rust-Powered Performance** — native core for parsing, transformation, and bundling
+- **Hybrid Transform Strategy** — OXC primary, SWC fallback
+- **Graph-based HMR** — intelligent hot module replacement based on dependency structure
+
+### Planned
+
+- **Analysis Dashboard** — visualize builds, cache hits, and dependency hot paths
+- **AI-Assisted Optimization** — auto-tune splits, targets, and bundle strategies
+- **Monorepo Support** — native workspace handling
+- **Remote Build Cache** — team-level caching infrastructure
+
+---
+
+## Language Stack
+
+| Component               | Technology          |
+| ----------------------- | ------------------- |
+| Core Engine             | Rust                |
+| CLI / SDK / Plugin API  | TypeScript          |
+| Graph Persistence       | Native (sled/SQLite)|
+| Primary Parser          | OXC                 |
+| Fallback Parser         | SWC                 |
+| Future Analyzer UI      | React + TypeScript  |
+
+---
+
+## Roadmap
+
+1. ✅ **Core Engine** — parser, graph, CAS, dev server
+2. ✅ **Unified Pipeline** — same engine for dev and production
+3. ✅ **Persistent Graph + Cache** — version-isolated storage
+4. 🔄 **Dependency Pipeline Stabilization** — robust node_modules handling
+5. ⏸️ **Plugin System** — paused for pipeline stabilization
+6. 📋 **Analyzer UI + Insights** — build visualization and metrics
+7. 📋 **AI Optimization Engine** — intelligent build recommendations
+8. 📋 **Monorepo / Remote Cache** — team collaboration features
+
+---
+
+## Philosophy
+
+Ionify is designed to be the infrastructure layer that frameworks and plugins rely on — not another framework itself.
+
+By unifying the build pipeline and persisting the dependency graph, Ionify creates a foundation for:
+- Smarter tooling that understands your project over time
+- Analysis and optimization based on real build patterns
+- Future AI-assisted recommendations grounded in actual data
+
+---
+
+## Links
+
+- **Website:** [ionify.cloud](https://ionify.cloud)
+- **GitHub:** [github.com/khaledM-salem/Ionify](https://github.com/khaledM-salem/Ionify)
+- **Issues:** [github.com/khaledM-salem/Ionify/issues](https://github.com/khaledM-salem/Ionify/issues)
+- **Contact:** contact@ionify.cloud
+
+---
+
+## License
+
+MIT © Khaled Salem

package/dist/cli/index.cjs

@@ -0,0 +1,219 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/tsup@8.5.1_@swc+core@1.15.4_postcss@8.5.6_tsx@4.21.0_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/cli/index.ts
+var import_commander = require("commander");
+
+// src/cli/utils/logger.ts
+var import_chalk = __toESM(require("chalk"), 1);
+function logInfo(message) {
+  console.log(import_chalk.default.cyan(`[Ionify] ${message}`));
+}
+function logError(message, err) {
+  console.error(import_chalk.default.red(`[Ionify] ${message}`));
+  if (err) console.error(err);
+}
+
+// src/cli/commands/analyze.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+
+// src/native/index.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_module = require("module");
+
+// src/core/version.ts
+var import_node_crypto = require("crypto");
+
+// src/native/index.ts
+function resolveCandidates() {
+  const cwd = process.cwd();
+  const releaseDir = import_path.default.resolve(cwd, "target", "release");
+  const debugDir = import_path.default.resolve(cwd, "target", "debug");
+  const nativeDir = import_path.default.resolve(cwd, "native");
+  const moduleDir = import_path.default.dirname(new URL(importMetaUrl).pathname);
+  const packageNativeDir = import_path.default.resolve(moduleDir, "..", "native");
+  const packageDistDir = import_path.default.resolve(moduleDir, "..");
+  const platformFile = process.platform === "win32" ? "ionify_core.dll" : process.platform === "darwin" ? "libionify_core.dylib" : "libionify_core.so";
+  const candidates = [
+    // Installed package locations (checked first)
+    import_path.default.join(packageDistDir, "ionify_core.node"),
+    import_path.default.join(packageNativeDir, "ionify_core.node"),
+    // Development locations
+    import_path.default.join(nativeDir, "ionify_core.node"),
+    import_path.default.join(releaseDir, "ionify_core.node"),
+    import_path.default.join(releaseDir, platformFile),
+    import_path.default.join(debugDir, "ionify_core.node"),
+    import_path.default.join(debugDir, platformFile)
+  ];
+  return candidates.filter((candidate) => {
+    try {
+      return import_fs.default.existsSync(candidate) && import_fs.default.statSync(candidate).isFile();
+    } catch {
+      return false;
+    }
+  });
+}
+var nativeBinding = null;
+(() => {
+  const require2 = (0, import_module.createRequire)(importMetaUrl);
+  for (const candidate of resolveCandidates()) {
+    try {
+      const mod = require2(candidate);
+      if (mod) {
+        nativeBinding = mod;
+        break;
+      }
+    } catch {
+    }
+  }
+})();
+var native = nativeBinding;
+
+// src/cli/commands/analyze.ts
+function readGraphFromDisk(root) {
+  const file = import_path2.default.join(root, ".ionify", "graph.json");
+  if (!import_fs2.default.existsSync(file)) return null;
+  try {
+    const raw = import_fs2.default.readFileSync(file, "utf8");
+    const snapshot = JSON.parse(raw);
+    if (snapshot?.version !== 1 || !snapshot?.nodes) return null;
+    return Object.entries(snapshot.nodes).map(([id, node]) => ({
+      id,
+      hash: node.hash ?? null,
+      deps: Array.isArray(node.deps) ? node.deps : []
+    }));
+  } catch (err) {
+    logError("Failed to read graph snapshot", err);
+    return null;
+  }
+}
+function computeSummary(nodes, limit = 10) {
+  const modules = nodes.length;
+  let edgeCount = 0;
+  const dependentCounts = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    for (const dep of node.deps) {
+      edgeCount += 1;
+      dependentCounts.set(dep, (dependentCounts.get(dep) ?? 0) + 1);
+    }
+  }
+  const densest = [...nodes].sort((a, b) => b.deps.length - a.deps.length).slice(0, limit).map((node) => ({ id: node.id, deps: node.deps.length }));
+  const mostDepended = [...dependentCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit).map(([id, count]) => ({ id, dependents: count }));
+  const orphanSet = new Set(nodes.map((n) => n.id));
+  for (const node of nodes) {
+    for (const dep of node.deps) {
+      orphanSet.delete(dep);
+    }
+  }
+  return {
+    modules,
+    edges: edgeCount,
+    averageDeps: modules === 0 ? 0 : edgeCount / modules,
+    densest,
+    mostDepended,
+    orphans: Array.from(orphanSet)
+  };
+}
+async function loadGraphSnapshot() {
+  if (native?.graphLoad) {
+    try {
+      const nodes = native.graphLoad();
+      if (Array.isArray(nodes)) {
+        return nodes.map((node) => ({
+          id: node.id,
+          hash: node.hash ?? null,
+          deps: Array.isArray(node.deps) ? node.deps : []
+        }));
+      }
+    } catch (err) {
+      logError("Failed to load native graph snapshot", err);
+    }
+  }
+  return readGraphFromDisk(process.cwd());
+}
+async function runAnalyzeCommand(options = {}) {
+  const nodes = await loadGraphSnapshot();
+  if (!nodes || nodes.length === 0) {
+    logInfo("No cached graph found. Run `ionify dev` to generate dependency data.");
+    return;
+  }
+  const summary = computeSummary(nodes, options.limit ?? 10);
+  if (options.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  logInfo("Ionify Graph Summary");
+  console.log(` Modules: ${summary.modules}`);
+  console.log(` Dependencies: ${summary.edges}`);
+  console.log(` Avg deps / module: ${summary.averageDeps.toFixed(2)}`);
+  if (summary.densest.length > 0) {
+    console.log("\n Top modules by dependency count:");
+    for (const entry of summary.densest) {
+      console.log(`  \u2022 ${entry.id} (${entry.deps})`);
+    }
+  }
+  if (summary.mostDepended.length > 0) {
+    console.log("\n Top modules by inbound dependents:");
+    for (const entry of summary.mostDepended) {
+      console.log(`  \u2022 ${entry.id} (${entry.dependents})`);
+    }
+  }
+  if (summary.orphans.length) {
+    console.log("\n Orphan modules (no dependents):");
+    for (const file of summary.orphans.slice(0, options.limit ?? 10)) {
+      console.log(`  \u2022 ${file}`);
+    }
+    if (summary.orphans.length > (options.limit ?? 10)) {
+      console.log(`  \u2022 \u2026and ${summary.orphans.length - (options.limit ?? 10)} more`);
+    }
+  }
+}
+
+// src/cli/index.ts
+var program = new import_commander.Command();
+program.name("ionify").description("Ionify \u2013 Instant, Intelligent, Unified Build Engine").version("0.1.0");
+program.command("dev").description("Start Ionify development server (coming in full release)").option("-p, --port <port>", "Port to run the server on", "5173").action(async () => {
+  logError("Dev server is not available in this release. Stay tuned!");
+  process.exit(1);
+});
+program.command("build").description("Build for production (coming in full release)").option("-o, --outDir <dir>", "Output directory", "dist").option("-l, --level <level>", "Optimization level (0-4)", "3").action(async () => {
+  logError("Build command is not available in this release. Stay tuned!");
+  process.exit(1);
+});
+program.command("analyze").description("Analyze bundle and performance").option("-f, --format <format>", "Output format (json|text)", "text").action(async (options) => {
+  try {
+    await runAnalyzeCommand(options);
+  } catch (err) {
+    logError(`Analyzer failed: ${err.message}`);
+    process.exit(1);
+  }
+});
+program.parse();

package/dist/cli/index.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli/index.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/cli/utils/logger.ts
+import chalk from "chalk";
+function logInfo(message) {
+  console.log(chalk.cyan(`[Ionify] ${message}`));
+}
+function logError(message, err) {
+  console.error(chalk.red(`[Ionify] ${message}`));
+  if (err) console.error(err);
+}
+
+// src/cli/commands/analyze.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/native/index.ts
+import fs from "fs";
+import path from "path";
+import { createRequire } from "module";
+
+// src/core/version.ts
+import { createHash } from "crypto";
+
+// src/native/index.ts
+function resolveCandidates() {
+  const cwd = process.cwd();
+  const releaseDir = path.resolve(cwd, "target", "release");
+  const debugDir = path.resolve(cwd, "target", "debug");
+  const nativeDir = path.resolve(cwd, "native");
+  const moduleDir = path.dirname(new URL(import.meta.url).pathname);
+  const packageNativeDir = path.resolve(moduleDir, "..", "native");
+  const packageDistDir = path.resolve(moduleDir, "..");
+  const platformFile = process.platform === "win32" ? "ionify_core.dll" : process.platform === "darwin" ? "libionify_core.dylib" : "libionify_core.so";
+  const candidates = [
+    // Installed package locations (checked first)
+    path.join(packageDistDir, "ionify_core.node"),
+    path.join(packageNativeDir, "ionify_core.node"),
+    // Development locations
+    path.join(nativeDir, "ionify_core.node"),
+    path.join(releaseDir, "ionify_core.node"),
+    path.join(releaseDir, platformFile),
+    path.join(debugDir, "ionify_core.node"),
+    path.join(debugDir, platformFile)
+  ];
+  return candidates.filter((candidate) => {
+    try {
+      return fs.existsSync(candidate) && fs.statSync(candidate).isFile();
+    } catch {
+      return false;
+    }
+  });
+}
+var nativeBinding = null;
+(() => {
+  const require2 = createRequire(import.meta.url);
+  for (const candidate of resolveCandidates()) {
+    try {
+      const mod = require2(candidate);
+      if (mod) {
+        nativeBinding = mod;
+        break;
+      }
+    } catch {
+    }
+  }
+})();
+var native = nativeBinding;
+
+// src/cli/commands/analyze.ts
+function readGraphFromDisk(root) {
+  const file = path2.join(root, ".ionify", "graph.json");
+  if (!fs2.existsSync(file)) return null;
+  try {
+    const raw = fs2.readFileSync(file, "utf8");
+    const snapshot = JSON.parse(raw);
+    if (snapshot?.version !== 1 || !snapshot?.nodes) return null;
+    return Object.entries(snapshot.nodes).map(([id, node]) => ({
+      id,
+      hash: node.hash ?? null,
+      deps: Array.isArray(node.deps) ? node.deps : []
+    }));
+  } catch (err) {
+    logError("Failed to read graph snapshot", err);
+    return null;
+  }
+}
+function computeSummary(nodes, limit = 10) {
+  const modules = nodes.length;
+  let edgeCount = 0;
+  const dependentCounts = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    for (const dep of node.deps) {
+      edgeCount += 1;
+      dependentCounts.set(dep, (dependentCounts.get(dep) ?? 0) + 1);
+    }
+  }
+  const densest = [...nodes].sort((a, b) => b.deps.length - a.deps.length).slice(0, limit).map((node) => ({ id: node.id, deps: node.deps.length }));
+  const mostDepended = [...dependentCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit).map(([id, count]) => ({ id, dependents: count }));
+  const orphanSet = new Set(nodes.map((n) => n.id));
+  for (const node of nodes) {
+    for (const dep of node.deps) {
+      orphanSet.delete(dep);
+    }
+  }
+  return {
+    modules,
+    edges: edgeCount,
+    averageDeps: modules === 0 ? 0 : edgeCount / modules,
+    densest,
+    mostDepended,
+    orphans: Array.from(orphanSet)
+  };
+}
+async function loadGraphSnapshot() {
+  if (native?.graphLoad) {
+    try {
+      const nodes = native.graphLoad();
+      if (Array.isArray(nodes)) {
+        return nodes.map((node) => ({
+          id: node.id,
+          hash: node.hash ?? null,
+          deps: Array.isArray(node.deps) ? node.deps : []
+        }));
+      }
+    } catch (err) {
+      logError("Failed to load native graph snapshot", err);
+    }
+  }
+  return readGraphFromDisk(process.cwd());
+}
+async function runAnalyzeCommand(options = {}) {
+  const nodes = await loadGraphSnapshot();
+  if (!nodes || nodes.length === 0) {
+    logInfo("No cached graph found. Run `ionify dev` to generate dependency data.");
+    return;
+  }
+  const summary = computeSummary(nodes, options.limit ?? 10);
+  if (options.json) {
+    console.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+  logInfo("Ionify Graph Summary");
+  console.log(` Modules: ${summary.modules}`);
+  console.log(` Dependencies: ${summary.edges}`);
+  console.log(` Avg deps / module: ${summary.averageDeps.toFixed(2)}`);
+  if (summary.densest.length > 0) {
+    console.log("\n Top modules by dependency count:");
+    for (const entry of summary.densest) {
+      console.log(`  \u2022 ${entry.id} (${entry.deps})`);
+    }
+  }
+  if (summary.mostDepended.length > 0) {
+    console.log("\n Top modules by inbound dependents:");
+    for (const entry of summary.mostDepended) {
+      console.log(`  \u2022 ${entry.id} (${entry.dependents})`);
+    }
+  }
+  if (summary.orphans.length) {
+    console.log("\n Orphan modules (no dependents):");
+    for (const file of summary.orphans.slice(0, options.limit ?? 10)) {
+      console.log(`  \u2022 ${file}`);
+    }
+    if (summary.orphans.length > (options.limit ?? 10)) {
+      console.log(`  \u2022 \u2026and ${summary.orphans.length - (options.limit ?? 10)} more`);
+    }
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("ionify").description("Ionify \u2013 Instant, Intelligent, Unified Build Engine").version("0.1.0");
+program.command("dev").description("Start Ionify development server (coming in full release)").option("-p, --port <port>", "Port to run the server on", "5173").action(async () => {
+  logError("Dev server is not available in this release. Stay tuned!");
+  process.exit(1);
+});
+program.command("build").description("Build for production (coming in full release)").option("-o, --outDir <dir>", "Output directory", "dist").option("-l, --level <level>", "Optimization level (0-4)", "3").action(async () => {
+  logError("Build command is not available in this release. Stay tuned!");
+  process.exit(1);
+});
+program.command("analyze").description("Analyze bundle and performance").option("-f, --format <format>", "Output format (json|text)", "text").action(async (options) => {
+  try {
+    await runAnalyzeCommand(options);
+  } catch (err) {
+    logError(`Analyzer failed: ${err.message}`);
+    process.exit(1);
+  }
+});
+program.parse();