@metaverse-systems/the-seed 1.0.4 → 1.2.1

package/src/Template.ts

@@ -1,9 +1,9 @@
-const fs = require("fs-extra");
-const { execSync } = require("child_process");
+import fs from "fs-extra";
+import { execSync } from "child_process";
 import path from "path";
-import os from "os";
 import Config from "./Config";
 import Scopes from "./Scopes";
+import { PackageType } from "./types";
 
 const build_command = "the-seed build native";
 const build_win64_command = "the-seed build windows";
@@ -13,7 +13,7 @@ class Template {
   packageDir = "";
   config: Config;
   scopes: Scopes;
-  package: any;
+  package?: PackageType;
 
   constructor(config: Config) {
     this.config = config;
@@ -36,17 +36,18 @@ class Template {
   };
 
   copyTemplate = (scope: string, name: string) => {
-    const templateDir = path.join(path.dirname(require.main!.filename), "../../templates/" +  this.type);
+    const templateDir = path.join(__dirname, "..", "templates", this.type);
     const scopeDir = this.config.config.prefix + "/projects/" + scope;
 
     const underscoreRegex = new RegExp("-", "g");
     const underscoreName = name.replace(underscoreRegex, "_");
     
     if(!fs.existsSync(scopeDir)) {
-      fs.mkdirSync(scopeDir);
+      fs.mkdirSync(scopeDir, { recursive: true });
     }
 
     // Create package from template
+    console.log("Copying template from " + templateDir + " to " + this.packageDir);
     fs.copySync(templateDir, this.packageDir);
 
     // Replace template variables with real values
@@ -90,14 +91,13 @@ class Template {
   };
 
   createPackage = (scope: string, name: string) => {
-    const scopeDir = this.config.config.prefix + "/projects/" + scope;
-    this.packageDir = scopeDir + "/" + name;
+    this.packageDir = name;
     this.copyTemplate(scope, name);
 
     // Create default package.json
     execSync("npm init --yes", { cwd: this.packageDir });
 
-    this.package = JSON.parse(fs.readFileSync(this.packageDir + "/package.json"));
+    this.package = JSON.parse(fs.readFileSync(this.packageDir + "/package.json").toString()) as PackageType;
     this.package.author = this.scopes.getScope(scope).author;
     this.package.license = "UNLICENSED";
     this.package.name = scope + "/" + name;
@@ -112,6 +112,7 @@ class Template {
   };
 
   save = () => {
+    if (!this.package) return;
     fs.writeFileSync(this.packageDir + "/package.json", JSON.stringify(this.package, null, 2));
   };
 }

package/src/index.ts

@@ -1,12 +1,23 @@
 import Config from "./Config";
 import Scopes from "./Scopes";
-import { AuthorType, ConfigType, ScopeType, ScopesType } from "./types";
+import Package from "./Package";
+import Build from "./Build";
+import { AuthorType, ConfigType, ScopeType, ScopesType, ScopeAnswersType, ScopeDefaultsType, ResourceType, PackageType, ScriptArgsType, DependencyResultType, BuildStep } from "./types";
 
 export {
   Config,
   Scopes,
+  Package,
+  Build,
   AuthorType,
   ConfigType,
   ScopeType,
-  ScopesType
+  ScopesType,
+  ScopeAnswersType,
+  ScopeDefaultsType,
+  ResourceType,
+  PackageType,
+  ScriptArgsType,
+  DependencyResultType,
+  BuildStep
 };

package/src/scripts/DependenciesCLI.ts

@@ -0,0 +1,57 @@
+import { checkLibEcs, checkLibTheSeed, installLibEcs, installLibTheSeed } from "../Dependencies";
+import Config from "../Config";
+import { ScriptArgsType } from "../types";
+
+const DependenciesCLI = (scriptConfig: ScriptArgsType) => {
+  const config = new Config(scriptConfig.configDir);
+
+  const command = scriptConfig.args[3];
+  const target = scriptConfig.args[4] ? scriptConfig.args[4] : "native";
+
+  switch (command) {
+    case "help":
+      console.log("\nUsage: the-seed dependencies <command>");
+      console.log("\nAvailable commands:");
+      console.log("  help       - Show this help message");
+      console.log("  check      - Check if dependencies are installed");
+      break;
+    case "check":
+      if (checkLibEcs(config, target)) {
+        console.log("libecs-cpp is installed.");
+      } else {
+        console.log("libecs-cpp is not installed.");
+      }
+      if (checkLibTheSeed(config, target)) {
+        console.log("libthe-seed is installed.");
+      } else {
+        console.log("libthe-seed is not installed.");
+      }
+      break;
+    case "install":
+      if (!checkLibEcs(config, target)) {
+        console.log("Installing libecs-cpp...");
+        if (installLibEcs(config, target)) {
+          console.log("libecs-cpp installed successfully.");
+        } else {
+          console.error("Failed to install libecs-cpp.");
+        }
+      }
+      if (!checkLibTheSeed(config, target)) {
+        console.log("Installing libthe-seed...");
+        if (installLibTheSeed(config, target)) {
+          console.log("libthe-seed installed successfully.");
+        } else {
+          console.error("Failed to install libthe-seed.");
+        }
+      }
+      break;
+    default:
+      console.log(
+        "Invalid command. Use 'the-seed dependencies help' for usage information."
+      );
+      break;
+  }
+  return true;
+};
+
+export default DependenciesCLI;

package/src/scripts/PackageCLI.ts

@@ -0,0 +1,42 @@
+import Config from "../Config";
+import Package from "../Package";
+import { ScriptArgsType } from "../types";
+
+const PackageCLI = (scriptConfig: ScriptArgsType) => {
+  const command = scriptConfig.args[3];
+
+  // No arguments or help subcommand
+  if (!command || command === "help") {
+    console.log("Usage: the-seed package <output-directory> <project-dir> [project-dir2] ...");
+    console.log("");
+    console.log("Package binaries with their shared library dependencies into a directory.");
+    console.log("");
+    console.log("Arguments:");
+    console.log("  output-directory  Name of the output directory to create");
+    console.log("  project-dir       Project directories containing src/Makefile.am");
+    console.log("");
+    console.log("The command reads src/Makefile.am to determine the binary type and name,");
+    console.log("resolves installed binaries for all build targets, uses DependencyLister");
+    console.log("to find shared library dependencies, and copies everything into the output directory.");
+    return;
+  }
+
+  const outputDir = command;
+  const projectDirs = scriptConfig.args.slice(4);
+
+  // No project directories specified
+  if (projectDirs.length === 0) {
+    console.error("Usage: the-seed package <output-directory> <project-dir> [project-dir2] ...");
+    process.exit(1);
+  }
+
+  const config = new Config(scriptConfig.configDir);
+  const pkg = new Package(config);
+  const success = pkg.run(outputDir, projectDirs);
+
+  if (!success) {
+    process.exit(1);
+  }
+};
+
+export default PackageCLI;

package/src/scripts/the-seed.ts

@@ -6,6 +6,8 @@ import ScopesCLI from  "./ScopesCLI";
 import TemplateCLI from "./TemplateCLI";
 import BuildCLI from "./BuildCLI";
 import ResourcePakCLI from "./ResourcePakCLI";
+import DependenciesCLI from "./DependenciesCLI";
+import PackageCLI from "./PackageCLI";
 import { ScriptArgsType } from "../types";
 
 const homedir = os.homedir;
@@ -21,10 +23,12 @@ const section = scriptConfig.args[2] || "help";
 switch(section)
 {
   case "help":
+    console.log(scriptConfig.binName + " dependencies");
     console.log(scriptConfig.binName + " build");
     console.log(scriptConfig.binName + " config");
     console.log(scriptConfig.binName + " scopes");
     console.log(scriptConfig.binName + " template");
+    console.log(scriptConfig.binName + " package");
     console.log(scriptConfig.binName + " resource-pak");
     break;
   case "config":
@@ -42,4 +46,13 @@ switch(section)
   case "resource-pak":
     ResourcePakCLI(scriptConfig);
     break;
+  case "dependencies":
+    DependenciesCLI(scriptConfig);
+    break;
+  case "package":
+    PackageCLI(scriptConfig);
+    break;
+  default:
+    console.log("Invalid command. Use 'the-seed help' for usage information.");
+    break;
 }

package/src/types.ts

@@ -13,7 +13,6 @@ export interface ScopesType {
 }
 
 export interface ConfigType {
-  [index: string]: any;
   prefix: string;
   scopes: ScopesType;
 }
@@ -28,7 +27,7 @@ export interface ResourceType {
   name: string;
   filename: string;
   size: number;
-  attributes?: any;
+  attributes?: { [key: string]: string };
 }
 
 export interface PackageType {
@@ -40,5 +39,32 @@ export interface PackageType {
     [index: string]: string;
   };
   resources: ResourceType[];
-  main?: any;
+  main?: string;
+}
+
+export interface ScopeAnswersType {
+  scopeName: string;
+  authorName: string;
+  authorEmail: string;
+  authorURL: string;
+}
+
+export interface ScopeDefaultsType {
+  name?: string;
+  email?: string;
+  url?: string;
+}
+
+export interface DependencyResultType {
+  dependencies: Record<string, string[]>;
+  errors: Record<string, string>;
+}
+
+export interface BuildStep {
+  /** Human-readable step name (e.g., 'autogen', 'configure', 'compile', 'install') */
+  label: string;
+  /** Shell command to execute */
+  command: string;
+  /** If true, non-zero exit codes do not abort the build (used for 'make distclean') */
+  ignoreExitCode?: boolean;
 }

package/test/Build.test.ts

@@ -0,0 +1,223 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import Config from "../src/Config";
+import Build, { targets } from "../src/Build";
+import { BuildStep } from "../src/types";
+
+jest.mock("child_process", () => ({
+  execSync: jest.fn(() => Buffer.from(""))
+}));
+
+import { execSync } from "child_process";
+const mockedExecSync = execSync as jest.MockedFunction<typeof execSync>;
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "build-test-"));
+}
+
+describe("test Build", () => {
+  let configDir: string;
+  let config: Config;
+  let build: Build;
+
+  beforeAll(() => {
+    configDir = createTempDir();
+    config = new Config(configDir);
+  });
+
+  beforeEach(() => {
+    build = new Build(config);
+    mockedExecSync.mockClear();
+    mockedExecSync.mockReturnValue(Buffer.from(""));
+  });
+
+  afterAll(() => {
+    fs.rmSync(configDir, { recursive: true });
+  });
+
+  describe("targets map", () => {
+    it("has correct target mappings", () => {
+      expect(targets["native"]).toBe("x86_64-linux-gnu");
+      expect(targets["windows"]).toBe("x86_64-w64-mingw32");
+    });
+  });
+
+  describe("autogen", () => {
+    it("runs autogen.sh", () => {
+      build.autogen();
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        "./autogen.sh",
+        expect.objectContaining({ stdio: "pipe" })
+      );
+    });
+
+    it("propagates errors", () => {
+      mockedExecSync.mockImplementation(() => {
+        throw new Error("autogen failed");
+      });
+      expect(() => build.autogen()).toThrow("autogen failed");
+    });
+  });
+
+  describe("configure", () => {
+    it("runs configure for native target", () => {
+      build.target = "native";
+      build.configure();
+
+      // First call is make distclean
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        "make distclean",
+        expect.anything()
+      );
+
+      // Second call is configure
+      const configureCalls = mockedExecSync.mock.calls.filter(
+        (call) => String(call[0]).includes("./configure")
+      );
+      expect(configureCalls.length).toBe(1);
+      const configureCmd = String(configureCalls[0][0]);
+      expect(configureCmd).toContain("--prefix=" + config.config.prefix + "/x86_64-linux-gnu");
+      expect(configureCmd).not.toContain("--host");
+    });
+
+    it("runs configure for windows target", () => {
+      build.target = "windows";
+      build.configure();
+
+      const configureCalls = mockedExecSync.mock.calls.filter(
+        (call) => String(call[0]).includes("./configure")
+      );
+      expect(configureCalls.length).toBe(1);
+      const configureCmd = String(configureCalls[0][0]);
+      expect(configureCmd).toContain("--host=x86_64-w64-mingw32");
+    });
+
+    it("runs distclean before configure", () => {
+      build.target = "native";
+      build.configure();
+
+      const calls = mockedExecSync.mock.calls.map((c) => String(c[0]));
+      const distcleanIndex = calls.findIndex((c) => c.includes("make distclean"));
+      const configureIndex = calls.findIndex((c) => c.includes("./configure"));
+      expect(distcleanIndex).toBeLessThan(configureIndex);
+    });
+  });
+
+  describe("reconfigure", () => {
+    it("chains autogen and configure", () => {
+      build.reconfigure("native");
+
+      const calls = mockedExecSync.mock.calls.map((c) => String(c[0]));
+      const autogenIndex = calls.findIndex((c) => c.includes("./autogen.sh"));
+      const configureIndex = calls.findIndex((c) => c.includes("./configure"));
+      expect(autogenIndex).toBeGreaterThanOrEqual(0);
+      expect(configureIndex).toBeGreaterThan(autogenIndex);
+    });
+  });
+
+  describe("compile", () => {
+    it("runs make -j", () => {
+      build.compile();
+      expect(mockedExecSync).toHaveBeenCalledWith("make -j");
+    });
+  });
+
+  describe("install", () => {
+    it("runs make install", () => {
+      build.install();
+      expect(mockedExecSync).toHaveBeenCalledWith("make install");
+    });
+  });
+
+  describe("getSteps", () => {
+    it("returns 5 steps for full native build", () => {
+      const steps: BuildStep[] = build.getSteps("native", true);
+      expect(steps).toHaveLength(5);
+      expect(steps.map(s => s.label)).toEqual([
+        "autogen", "distclean", "configure", "compile", "install"
+      ]);
+    });
+
+    it("returns 5 steps for full windows build", () => {
+      const steps: BuildStep[] = build.getSteps("windows", true);
+      expect(steps).toHaveLength(5);
+      expect(steps.map(s => s.label)).toEqual([
+        "autogen", "distclean", "configure", "compile", "install"
+      ]);
+    });
+
+    it("returns 2 steps for incremental build (fullReconfigure=false)", () => {
+      const steps: BuildStep[] = build.getSteps("native", false);
+      expect(steps).toHaveLength(2);
+      expect(steps.map(s => s.label)).toEqual(["compile", "install"]);
+    });
+
+    it("native configure step does not contain --host flag", () => {
+      const steps = build.getSteps("native", true);
+      const configureStep = steps.find(s => s.label === "configure");
+      expect(configureStep).toBeDefined();
+      expect(configureStep!.command).not.toContain("--host");
+    });
+
+    it("windows configure step contains --host=x86_64-w64-mingw32", () => {
+      const steps = build.getSteps("windows", true);
+      const configureStep = steps.find(s => s.label === "configure");
+      expect(configureStep).toBeDefined();
+      expect(configureStep!.command).toContain("--host=x86_64-w64-mingw32");
+    });
+
+    it("distclean step has ignoreExitCode set to true", () => {
+      const steps = build.getSteps("native", true);
+      const distcleanStep = steps.find(s => s.label === "distclean");
+      expect(distcleanStep).toBeDefined();
+      expect(distcleanStep!.ignoreExitCode).toBe(true);
+    });
+
+    it("non-distclean steps do not have ignoreExitCode set to true", () => {
+      const steps = build.getSteps("native", true);
+      const nonDistclean = steps.filter(s => s.label !== "distclean");
+      for (const step of nonDistclean) {
+        expect(step.ignoreExitCode).toBeFalsy();
+      }
+    });
+
+    it("configure step includes correct prefix path for native", () => {
+      const steps = build.getSteps("native", true);
+      const configureStep = steps.find(s => s.label === "configure");
+      const expectedPrefix = config.config.prefix + "/x86_64-linux-gnu";
+      expect(configureStep!.command).toContain("--prefix=" + expectedPrefix);
+      expect(configureStep!.command).toContain("PKG_CONFIG_PATH=" + expectedPrefix + "/lib/pkgconfig/");
+    });
+
+    it("configure step includes correct prefix path for windows", () => {
+      const steps = build.getSteps("windows", true);
+      const configureStep = steps.find(s => s.label === "configure");
+      const expectedPrefix = config.config.prefix + "/x86_64-w64-mingw32";
+      expect(configureStep!.command).toContain("--prefix=" + expectedPrefix);
+    });
+
+    it("autogen step command is ./autogen.sh", () => {
+      const steps = build.getSteps("native", true);
+      expect(steps[0].command).toBe("./autogen.sh");
+    });
+
+    it("compile step command is make -j", () => {
+      const steps = build.getSteps("native", true);
+      const compileStep = steps.find(s => s.label === "compile");
+      expect(compileStep!.command).toBe("make -j");
+    });
+
+    it("install step command is make install", () => {
+      const steps = build.getSteps("native", true);
+      const installStep = steps.find(s => s.label === "install");
+      expect(installStep!.command).toBe("make install");
+    });
+
+    it("incremental build for windows returns 2 steps", () => {
+      const steps = build.getSteps("windows", false);
+      expect(steps).toHaveLength(2);
+      expect(steps.map(s => s.label)).toEqual(["compile", "install"]);
+    });
+  });
+});

package/test/Config.test.ts

@@ -24,7 +24,7 @@ describe("test Config", () => {
   });
 
   it("write updated config file", () => {
-    config.config["prefix"] = prefix;
+    config.config.prefix = prefix;
     config.saveConfig();
   });
 

package/test/Dependencies.test.ts

@@ -0,0 +1,153 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import Config from "../src/Config";
+import {
+  checkLib,
+  checkLibEcs,
+  checkLibTheSeed,
+  installLib,
+  installLibEcs,
+  installLibTheSeed
+} from "../src/Dependencies";
+
+jest.mock("child_process", () => ({
+  execSync: jest.fn(() => Buffer.from(""))
+}));
+
+import { execSync } from "child_process";
+const mockedExecSync = execSync as jest.MockedFunction<typeof execSync>;
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "deps-test-"));
+}
+
+describe("test Dependencies", () => {
+  let configDir: string;
+  let config: Config;
+
+  beforeAll(() => {
+    configDir = createTempDir();
+    config = new Config(configDir);
+  });
+
+  beforeEach(() => {
+    mockedExecSync.mockClear();
+    mockedExecSync.mockReturnValue(Buffer.from(""));
+  });
+
+  afterAll(() => {
+    fs.rmSync(configDir, { recursive: true });
+  });
+
+  describe("checkLib", () => {
+    it("returns true when library is found", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("-l ecs-cpp -I/usr/include/ecs-cpp"));
+      const result = checkLib(config, "ecs-cpp", "native");
+      expect(result).toBe(true);
+    });
+
+    it("returns false when pkg-config throws", () => {
+      mockedExecSync.mockImplementation(() => {
+        throw new Error("pkg-config not found");
+      });
+      const result = checkLib(config, "ecs-cpp", "native");
+      expect(result).toBe(false);
+    });
+
+    it("returns false when output does not include library name", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("-l other-lib"));
+      const result = checkLib(config, "ecs-cpp", "native");
+      expect(result).toBe(false);
+    });
+  });
+
+  describe("checkLibEcs", () => {
+    it("delegates to checkLib with ecs-cpp", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("-l ecs-cpp"));
+      const result = checkLibEcs(config, "native");
+      expect(result).toBe(true);
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        expect.stringContaining("ecs-cpp"),
+        expect.anything()
+      );
+    });
+  });
+
+  describe("checkLibTheSeed", () => {
+    it("delegates to checkLib with the-seed", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("-l the-seed"));
+      const result = checkLibTheSeed(config, "native");
+      expect(result).toBe(true);
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        expect.stringContaining("the-seed"),
+        expect.anything()
+      );
+    });
+  });
+
+  describe("installLib", () => {
+    it("returns true on success", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("ok"));
+      const result = installLib(config, "https://github.com/test/repo.git", "test-dir", "native");
+      expect(result).toBe(true);
+    });
+
+    it("returns false on build failure", () => {
+      // First call (clone) succeeds, second call (build) throws
+      mockedExecSync
+        .mockReturnValueOnce(Buffer.from("cloned"))
+        .mockImplementationOnce(() => {
+          throw new Error("build failed");
+        });
+      const result = installLib(config, "https://github.com/test/repo.git", "test-dir", "native");
+      expect(result).toBe(false);
+    });
+
+    it("native target has no --host flag", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("ok"));
+      installLib(config, "https://github.com/test/repo.git", "test-dir", "native");
+
+      const buildCall = mockedExecSync.mock.calls.find(
+        (call) => String(call[0]).includes("./configure")
+      );
+      expect(buildCall).toBeDefined();
+      expect(String(buildCall![0])).not.toContain("--host");
+    });
+
+    it("windows target includes --host flag", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("ok"));
+      installLib(config, "https://github.com/test/repo.git", "test-dir", "windows");
+
+      const buildCall = mockedExecSync.mock.calls.find(
+        (call) => String(call[0]).includes("./configure")
+      );
+      expect(buildCall).toBeDefined();
+      expect(String(buildCall![0])).toContain("--host=x86_64-w64-mingw32");
+    });
+  });
+
+  describe("installLibEcs", () => {
+    it("delegates to installLib with libecs-cpp repo", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("ok"));
+      const result = installLibEcs(config, "native");
+      expect(result).toBe(true);
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        expect.stringContaining("libecs-cpp"),
+        expect.anything()
+      );
+    });
+  });
+
+  describe("installLibTheSeed", () => {
+    it("delegates to installLib with libthe-seed repo", () => {
+      mockedExecSync.mockReturnValue(Buffer.from("ok"));
+      const result = installLibTheSeed(config, "native");
+      expect(result).toBe(true);
+      expect(mockedExecSync).toHaveBeenCalledWith(
+        expect.stringContaining("libthe-seed"),
+        expect.anything()
+      );
+    });
+  });
+});