@kithinji/pod 1.0.0

package/src/macros/index.ts

@@ -0,0 +1,2 @@
+export * from "./expand_macros";
+export * from "./macro_executer";

package/src/macros/macro_executer.ts

@@ -0,0 +1,189 @@
+import * as vm from "node:vm";
+import * as esbuild from "esbuild";
+import * as path from "node:path";
+import Module from "node:module";
+import * as fs from "node:fs";
+
+type MacroFunction = Function & { name: string };
+type LoadedMacros = Record<string, MacroFunction>;
+
+export class MacroExecutor {
+  private cache = new Map<string, LoadedMacros>();
+
+  getMacro(specifier: string, macroName?: string): MacroFunction {
+    if (!this.cache.has(specifier)) {
+      this.load(specifier);
+    }
+    const macros = this.cache.get(specifier)!;
+    if (macroName) {
+      const fn = macros[macroName];
+      if (!fn) {
+        throw new Error(`Macro "${macroName}" not found in ${specifier}`);
+      }
+      return fn;
+    }
+    const names = Object.keys(macros);
+    if (names.length === 1) {
+      return macros[names[0]];
+    }
+    if (macros.default) {
+      return macros.default;
+    }
+    throw new Error(`Multiple macros in ${specifier}: ${names.join(", ")}`);
+  }
+
+  private load(specifier: string) {
+    const requireFromHere = Module.createRequire(
+      process.cwd() + "/package.json"
+    );
+    const entry = requireFromHere.resolve(specifier);
+
+    const { outputFiles } = esbuild.buildSync({
+      entryPoints: [entry],
+      bundle: true,
+      write: false,
+      platform: "node",
+      format: "cjs",
+      external: [
+        ...Module.builtinModules,
+        ...Module.builtinModules.map((m) => `node:${m}`),
+      ],
+      target: "node18",
+      mainFields: ["module", "main"],
+      conditions: ["node", "import", "require"],
+      packages: "bundle",
+      logLevel: "warning",
+    });
+
+    const code = outputFiles[0].text;
+    const sandboxRequire = Module.createRequire(entry);
+
+    const sandbox: any = {
+      // Module system
+      module: { exports: {} },
+      exports: {},
+      require: sandboxRequire,
+
+      console,
+      Buffer,
+      URL,
+      URLSearchParams,
+      TextEncoder,
+      TextDecoder,
+      atob,
+      btoa,
+
+      __filename: entry,
+      __dirname: path.dirname(entry),
+
+      process: {
+        env: process.env,
+        cwd: process.cwd,
+        version: process.version,
+        versions: process.versions,
+        platform: process.platform,
+        arch: process.arch,
+        argv: process.argv,
+        execPath: process.execPath,
+        pid: process.pid,
+      },
+
+      setTimeout,
+      setInterval,
+      setImmediate,
+      clearTimeout,
+      clearInterval,
+      clearImmediate,
+
+      Promise,
+
+      Object,
+      Array,
+      String,
+      Number,
+      Boolean,
+      Date,
+      Math,
+      JSON,
+      RegExp,
+      Error,
+      TypeError,
+      RangeError,
+      SyntaxError,
+      Map,
+      Set,
+      WeakMap,
+      WeakSet,
+      Symbol,
+      BigInt,
+      Proxy,
+      Reflect,
+    };
+
+    sandbox.global = sandbox;
+    sandbox.globalThis = sandbox;
+
+    const context = vm.createContext(sandbox, {
+      name: `macro-${path.basename(entry)}`,
+      codeGeneration: {
+        strings: true,
+        wasm: false,
+      },
+    });
+
+    try {
+      const script = new vm.Script(code, {
+        filename: entry,
+        lineOffset: 0,
+        columnOffset: 0,
+      });
+
+      script.runInContext(context, {
+        breakOnSigint: true,
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to execute macro from ${specifier}: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+
+    const macros: LoadedMacros = {};
+    const exports = sandbox.module.exports;
+
+    if (typeof exports === "function") {
+      macros.default = exports;
+    } else if (typeof exports === "object" && exports !== null) {
+      for (const [name, value] of Object.entries(exports)) {
+        if (typeof value === "function" && name.endsWith("$")) {
+          macros[name] = value as MacroFunction;
+        }
+      }
+
+      if (typeof exports.default === "function") {
+        macros.default = exports.default;
+      }
+    }
+
+    if (!Object.keys(macros).length) {
+      throw new Error(`No macros found in ${specifier}`);
+    }
+
+    this.cache.set(specifier, macros);
+  }
+
+  clearCache(specifier?: string) {
+    if (specifier) {
+      this.cache.delete(specifier);
+    } else {
+      this.cache.clear();
+    }
+  }
+}
+
+const macroExecutor = new MacroExecutor();
+
+export function macroExecuter(): MacroExecutor {
+  return macroExecutor;
+}

package/src/main.ts

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { startDevServer } from "./dev";
+
+import * as store from "./store";
+export { store };
+
+import * as config from "./config";
+export { config };
+
+export * from "./config/config";
+
+import * as macros from "./macros";
+export { macros };
+
+export * from "./macros/expand_macros";
+
+import * as plugins from "./plugins";
+export { plugins };
+export * from "./plugins/css";
+
+import { addComponent, addNew } from "./add";
+import { addFeature } from "./add/module";
+
+import path from "path";
+import { execSync } from "child_process";
+import { dockerize } from "./docker";
+
+const program = new Command();
+
+program.name("pod").description("Pod cli tool").version("0.0.0");
+
+program
+  .command("new <name>")
+  .description("Start a new Pod Project")
+  .action(async (name: string) => {
+    await addNew(name);
+
+    const appDir = path.resolve(process.cwd(), name);
+
+    console.log("Installing dependencies...");
+    execSync("npm install", { stdio: "inherit", cwd: appDir });
+
+    console.log("Starting development server...");
+    execSync("npm run dev", { stdio: "inherit", cwd: appDir });
+
+    console.log(`All done! Your app "${name}" is running in development mode.`);
+  });
+
+program
+  .command("dev")
+  .description("Start Pod development server")
+  .action(async (opts) => {
+    await startDevServer();
+  });
+
+program
+  .command("add <type> <name>")
+  .description("Add a component (c) or a feature (f)")
+  .action(async (type, name) => {
+    try {
+      if (type === "c") {
+        await addComponent(name);
+      } else if (type === "f") {
+        await addFeature(name);
+      } else {
+        console.error("❌ Unknown type. Use 'c' or 'f'.");
+      }
+    } catch (err: any) {
+      console.error("❌ Error:", err.message);
+    }
+  });
+
+program
+  .command("dockerize <env>")
+  .description("Dockerize a pod project.")
+  .action(async (env) => {
+    try {
+      await dockerize(env);
+    } catch (err: any) {
+      console.error("❌ Error:", err.message);
+    }
+  });
+
+program
+  .command("deploy <type> <options>")
+  .description("Deploy a Pod Project")
+  .action(async (type, name) => {
+    try {
+    } catch (err: any) {
+      console.error("❌ Error:", err.message);
+    }
+  });
+
+program.parse(process.argv);

package/src/plugins/analyzers/graph.ts

@@ -0,0 +1,291 @@
+import { parseSync } from "@swc/core";
+import * as fs from "fs";
+import * as path from "path";
+import type { Module, Decorator } from "@swc/core";
+
+type SymbolKind =
+  | "class"
+  | "function"
+  | "variable"
+  | "interface"
+  | "type"
+  | "enum"
+  | "namespace"
+  | "unknown";
+
+interface SymbolInfo {
+  name: string;
+  kind: SymbolKind;
+  decorators?: string[];
+  isDefault?: boolean;
+}
+
+interface ImportInfo {
+  sourcePath: string;
+  resolvedPath: string | null;
+  symbols: SymbolInfo[];
+}
+
+export interface FileNode {
+  filePath: string;
+  isTsx: boolean;
+  directive: "public" | "interactive" | null;
+  imports: ImportInfo[];
+  exports: SymbolInfo[];
+}
+
+export interface DependencyGraph {
+  [filePath: string]: FileNode;
+}
+
+function resolveFilePath(fromFile: string, importPath: string): string | null {
+  if (!importPath.startsWith(".")) {
+    return null;
+  }
+
+  const dir = path.dirname(fromFile);
+  const basePath = path.resolve(dir, importPath);
+
+  const extensions = ["", ".ts", ".tsx", ".js", ".jsx"];
+  for (const ext of extensions) {
+    const fullPath = basePath + ext;
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isFile()) {
+      return fullPath;
+    }
+  }
+
+  const indexFiles = ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+  for (const indexFile of indexFiles) {
+    const fullPath = basePath + indexFile;
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+
+  return null;
+}
+
+function extractDecorators(decorators?: Decorator[]): string[] {
+  if (!decorators || decorators.length === 0) return [];
+
+  return decorators
+    .map((decorator) => {
+      if (decorator.expression.type === "CallExpression") {
+        if (decorator.expression.callee.type === "Identifier") {
+          return decorator.expression.callee.value;
+        }
+      } else if (decorator.expression.type === "Identifier") {
+        return decorator.expression.value;
+      }
+      return "unknown";
+    })
+    .filter((name) => name !== "unknown");
+}
+
+function extractDirective(ast: Module): "public" | "interactive" | null {
+  for (const item of ast.body) {
+    if (
+      item.type === "ExpressionStatement" &&
+      item.expression.type === "StringLiteral"
+    ) {
+      const value = item.expression.value;
+      if (value === "use public") return "public";
+      if (value === "use interactive") return "interactive";
+    }
+    if (
+      item.type !== "ExpressionStatement" ||
+      item.expression.type !== "StringLiteral"
+    ) {
+      break;
+    }
+  }
+  return null;
+}
+
+function extractExports(ast: Module): SymbolInfo[] {
+  const exports: SymbolInfo[] = [];
+
+  for (const item of ast.body) {
+    if (item.type === "ExportDeclaration" && item.declaration) {
+      const decl = item.declaration;
+
+      if (decl.type === "ClassDeclaration" && decl.identifier) {
+        const decorators = extractDecorators(decl.decorators);
+        exports.push({
+          name: decl.identifier.value,
+          kind: "class",
+          decorators: decorators.length > 0 ? decorators : undefined,
+        });
+      } else if (decl.type === "FunctionDeclaration" && decl.identifier) {
+        exports.push({ name: decl.identifier.value, kind: "function" });
+      } else if (decl.type === "VariableDeclaration") {
+        for (const declarator of decl.declarations) {
+          if (declarator.id.type === "Identifier") {
+            exports.push({ name: declarator.id.value, kind: "variable" });
+          }
+        }
+      } else if (decl.type === "TsInterfaceDeclaration") {
+        exports.push({ name: decl.id.value, kind: "interface" });
+      } else if (decl.type === "TsTypeAliasDeclaration") {
+        exports.push({ name: decl.id.value, kind: "type" });
+      } else if (decl.type === "TsEnumDeclaration") {
+        exports.push({ name: decl.id.value, kind: "enum" });
+      }
+    }
+
+    if (item.type === "ExportNamedDeclaration") {
+      for (const spec of item.specifiers) {
+        if (spec.type === "ExportSpecifier") {
+          exports.push({ name: spec.orig.value, kind: "unknown" });
+        }
+      }
+    }
+
+    if (item.type === "ExportDefaultDeclaration") {
+      const decl = item.decl;
+      let kind: SymbolKind = "unknown";
+      let decorators: string[] | undefined;
+
+      if (decl.type === "ClassExpression") {
+        kind = "class";
+        decorators = extractDecorators(decl.decorators);
+      } else if (decl.type === "FunctionExpression") {
+        kind = "function";
+      } else if (decl.type === "TsInterfaceDeclaration") {
+        kind = "interface";
+      }
+
+      exports.push({
+        name: "default",
+        kind,
+        isDefault: true,
+        decorators:
+          decorators && decorators.length > 0 ? decorators : undefined,
+      });
+    }
+
+    if (item.type === "ExportDefaultExpression") {
+      exports.push({ name: "default", kind: "unknown", isDefault: true });
+    }
+  }
+
+  return exports;
+}
+
+function extractImports(
+  ast: Module
+): Array<{ path: string; specifiers: any[] }> {
+  const imports: Array<{ path: string; specifiers: any[] }> = [];
+
+  for (const item of ast.body) {
+    if (item.type === "ImportDeclaration") {
+      imports.push({
+        path: item.source.value,
+        specifiers: item.specifiers,
+      });
+    }
+  }
+
+  return imports;
+}
+
+export function buildGraph(entryPoints: string[]): DependencyGraph {
+  const graph: DependencyGraph = {};
+  const visited = new Set<string>();
+
+  function processFile(filePath: string): void {
+    const allowed =
+      filePath.endsWith(".ts") ||
+      filePath.endsWith(".tsx") ||
+      filePath.endsWith(".js") ||
+      filePath.endsWith(".jsx");
+
+    if (!allowed) return;
+
+    if (visited.has(filePath)) return;
+    visited.add(filePath);
+
+    if (!fs.existsSync(filePath)) {
+      console.warn(`File not found: ${filePath}`);
+      return;
+    }
+
+    const isTsx = filePath.endsWith(".tsx") || filePath.endsWith(".jsx");
+
+    const content = fs.readFileSync(filePath, "utf-8");
+    const ast = parseSync(content, {
+      syntax: "typescript",
+      tsx: isTsx,
+      decorators: true,
+    });
+
+    const directive = extractDirective(ast);
+    const exports = extractExports(ast);
+    const rawImports = extractImports(ast);
+
+    for (const { path: importPath } of rawImports) {
+      const resolved = resolveFilePath(filePath, importPath);
+      if (resolved) {
+        processFile(resolved);
+      }
+    }
+
+    const imports: ImportInfo[] = [];
+    for (const { path: importPath, specifiers } of rawImports) {
+      const resolvedPath = resolveFilePath(filePath, importPath);
+      const sourceExports =
+        resolvedPath && graph[resolvedPath] ? graph[resolvedPath].exports : [];
+      const symbols: SymbolInfo[] = [];
+
+      for (const spec of specifiers) {
+        if (spec.type === "ImportDefaultSpecifier") {
+          const defaultExport = sourceExports.find((e) => e.isDefault);
+          symbols.push({
+            name: spec.local.value,
+            kind: defaultExport?.kind || "unknown",
+            decorators: defaultExport?.decorators,
+            isDefault: true,
+          });
+        } else if (spec.type === "ImportNamespaceSpecifier") {
+          symbols.push({
+            name: spec.local.value,
+            kind: "namespace",
+          });
+        } else if (spec.type === "ImportSpecifier") {
+          const importedName = spec.imported
+            ? spec.imported.value
+            : spec.local.value;
+          const exportedSymbol = sourceExports.find(
+            (e) => e.name === importedName
+          );
+          symbols.push({
+            name: importedName,
+            kind: exportedSymbol?.kind || "unknown",
+            decorators: exportedSymbol?.decorators,
+          });
+        }
+      }
+
+      imports.push({
+        sourcePath: importPath,
+        resolvedPath,
+        symbols,
+      });
+    }
+
+    graph[filePath] = {
+      filePath,
+      isTsx,
+      directive,
+      imports,
+      exports,
+    };
+  }
+
+  for (const entry of entryPoints) {
+    const resolved = path.resolve(entry);
+    processFile(resolved);
+  }
+
+  return graph;
+}

package/src/plugins/css/index.ts

@@ -0,0 +1,25 @@
+import { Store } from "@/store";
+import { PluginBuild } from "esbuild";
+import * as fs from "fs";
+
+export function stylePlugin(store: Store) {
+  return {
+    name: "style",
+    setup(build: PluginBuild) {
+      build.onEnd(() => {
+        const styleRules = store.get("style_rules");
+
+        if (!styleRules || styleRules.length === 0) {
+          console.log("No style rules generated");
+          return;
+        }
+
+        const allRules = styleRules.flat();
+        const uniqueRules = [...new Set(allRules)];
+
+        const cssOutput = uniqueRules.join("\n");
+        fs.writeFileSync("public/index.css", cssOutput);
+      });
+    },
+  };
+}