@kithinji/pod 1.0.21 → 1.0.23

package/src/macros/index.ts

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

package/src/macros/macro_executer.ts

@@ -1,189 +0,0 @@
-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

@@ -1,106 +0,0 @@
-#!/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";
-import { deploy } from "./deploy";
-import chalk from "chalk";
-
-const program = new Command();
-
-program.name("pod").description("Pod cli tool").version("1.0.21");
-
-program
-  .command("new <name>")
-  .description("Start a new Pod Project")
-  .action(async (name: string) => {
-    await addNew(name);
-
-    const appDir = path.resolve(process.cwd(), name);
-
-    const shell =
-      process.platform === "win32"
-        ? process.env.ComSpec || "cmd.exe"
-        : "/bin/sh";
-
-    console.log("Installing dependencies...");
-    execSync("npm install", { stdio: "inherit", cwd: appDir, shell });
-
-    console.log("Starting development server...");
-    execSync("npm run dev", { stdio: "inherit", cwd: appDir, shell });
-
-    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")
-  .description("Deploy to a target environment")
-  .argument("<target>", "Target environment (e.g., ec2)")
-  .option("--force-install", "Force reinstallation even if already installed")
-  .action(async (target: string, options: { forceEnsure?: boolean }) => {
-    try {
-      await deploy(target, options);
-    } catch (error: any) {
-      console.error(chalk.red(error.message));
-      process.exit(1);
-    }
-  });
-
-program.parse(process.argv);

package/src/plugins/analyzers/graph.ts

@@ -1,279 +0,0 @@
-import { parseSync } from "@swc/core";
-import * as fs from "fs";
-import * as path from "path";
-import type { Module, Decorator } from "@swc/core";
-import { Store } from "@/store";
-
-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) && fs.statSync(fullPath).isFile())
-      return fullPath;
-  }
-
-  return null;
-}
-
-function extractDecorators(decorators?: Decorator[]): string[] {
-  if (!decorators) return [];
-  return decorators
-    .map((d) => {
-      const exp = d.expression;
-      if (exp.type === "CallExpression" && exp.callee.type === "Identifier")
-        return exp.callee.value;
-      if (exp.type === "Identifier") return exp.value;
-      return "unknown";
-    })
-    .filter((n) => n !== "unknown");
-}
-
-function extractDirective(ast: Module): "public" | "interactive" | null {
-  for (const item of ast.body) {
-    if (
-      item.type === "ExpressionStatement" &&
-      item.expression.type === "StringLiteral"
-    ) {
-      const val = item.expression.value;
-      if (val === "use public") return "public";
-      if (val === "use interactive") return "interactive";
-    } else {
-      break;
-    }
-  }
-  return null;
-}
-
-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;
-}
-
-function extractExports(
-  ast: Module,
-  currentFile: string,
-  graph: DependencyGraph,
-  processFile: (fp: string) => void
-): 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" && item.source) {
-      const resolved = resolveFilePath(currentFile, item.source.value);
-      if (resolved) {
-        processFile(resolved);
-        const sourceExports = graph[resolved]?.exports || [];
-        for (const spec of item.specifiers) {
-          if (spec.type === "ExportSpecifier") {
-            const exp = sourceExports.find((e) => e.name === spec.orig.value);
-            exports.push({
-              name: spec.exported?.value || spec.orig.value,
-              kind: exp?.kind || "unknown",
-              decorators: exp?.decorators,
-            });
-          }
-        }
-      }
-    }
-
-    if (item.type === "ExportAllDeclaration") {
-      const resolved = resolveFilePath(currentFile, item.source.value);
-      if (resolved) {
-        processFile(resolved);
-        const sourceExports = graph[resolved]?.exports || [];
-        for (const exp of sourceExports) {
-          exports.push({ ...exp });
-        }
-      }
-    }
-
-    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?.length ? decorators : undefined,
-      });
-    }
-
-    if (item.type === "ExportDefaultExpression") {
-      exports.push({ name: "default", kind: "unknown", isDefault: true });
-    }
-  }
-
-  return exports;
-}
-
-export function buildGraph(entryPoints: string[]): DependencyGraph {
-  const graph: DependencyGraph = {};
-  const visited = new Set<string>();
-
-  function processFile(filePath: string): void {
-    const allowedExt = [".ts", ".tsx", ".js", ".jsx"];
-    if (!allowedExt.includes(path.extname(filePath))) return;
-    if (visited.has(filePath)) return;
-    visited.add(filePath);
-
-    if (!fs.existsSync(filePath)) {
-      console.warn(`File not found: ${filePath}`);
-      return;
-    }
-
-    const isTsx = [".tsx", ".jsx"].includes(path.extname(filePath));
-    const store = Store.getInstance();
-    const newCode = store.get<string>(filePath);
-    const content = newCode ? newCode[0] : fs.readFileSync(filePath, "utf-8");
-
-    const ast = parseSync(content, {
-      syntax: "typescript",
-      tsx: isTsx,
-      decorators: true,
-    });
-
-    const directive = extractDirective(ast);
-    const rawImports = extractImports(ast);
-    const exports = extractExports(ast, filePath, graph, processFile);
-
-    for (const { path: importPath } of rawImports) {
-      const resolved = resolveFilePath(filePath, importPath);
-      if (resolved) processFile(resolved);
-    }
-
-    const imports: ImportInfo[] = rawImports.map(
-      ({ path: importPath, specifiers }) => {
-        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 def = sourceExports.find((e) => e.isDefault);
-            symbols.push({
-              name: spec.local.value,
-              kind: def?.kind || "unknown",
-              decorators: def?.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 exp = sourceExports.find((e) => e.name === importedName);
-            symbols.push({
-              name: importedName,
-              kind: exp?.kind || "unknown",
-              decorators: exp?.decorators,
-            });
-          }
-        }
-
-        return { sourcePath: importPath, resolvedPath, symbols };
-      }
-    );
-
-    graph[filePath] = { filePath, isTsx, directive, imports, exports };
-  }
-
-  for (const entry of entryPoints) processFile(path.resolve(entry));
-
-  return graph;
-}

package/src/plugins/css/index.ts

@@ -1,25 +0,0 @@
-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);
-      });
-    },
-  };
-}