@metaverse-systems/the-seed 1.0.2 → 1.2.0

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/ResourcePakCLI.ts

@@ -0,0 +1,38 @@
+import Config from "../Config";
+import { ScriptArgsType } from "../types";
+import ResourcePak from "../ResourcePak";
+import inquirer from "inquirer";
+
+const ResourcePakCLI = (scriptConfig: ScriptArgsType) => {
+  const config = new Config(scriptConfig.configDir);
+  const command = scriptConfig.args[3];
+  const name = scriptConfig.args[4];
+  
+  let rp: ResourcePak;
+
+  switch(command) {
+    case "help":
+      console.log("Available resource-pak commands:");
+      console.log("  create <name>");
+      console.log("  add <resource-name> <filename>");
+      console.log("  build");
+      break;
+    case "create":
+      rp = new ResourcePak(config);
+      inquirer.prompt(rp.askName())
+        .then((answers) => {
+          rp.createPackage(answers.scopeName, answers.pakName);
+        });
+      break;
+    case "add":
+      rp = new ResourcePak(config);
+      rp.addResource(name, scriptConfig.args[5]);
+      break;
+    case "build":
+      rp = new ResourcePak(config);
+      rp.build();
+      break;
+  }
+};
+
+export default ResourcePakCLI;

package/src/scripts/the-seed.ts

@@ -5,6 +5,9 @@ import ConfigCLI from "./ConfigCLI";
 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;
@@ -20,10 +23,13 @@ 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":
     ConfigCLI(scriptConfig);
@@ -36,4 +42,17 @@ switch(section)
     break;
   case "build":
     BuildCLI(scriptConfig);
+    break;
+  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;
 }
@@ -23,3 +22,49 @@ export interface ScriptArgsType {
   args: string[];
   configDir: string;
 }
+
+export interface ResourceType {
+  name: string;
+  filename: string;
+  size: number;
+  attributes?: { [key: string]: string };
+}
+
+export interface PackageType {
+  author: AuthorType;
+  name: string;
+  license: string;
+  version: string;
+  scripts: {
+    [index: string]: string;
+  };
+  resources: ResourceType[];
+  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/structure.md

@@ -13,9 +13,6 @@
 ```
     |-- ~/the-seed
         |-- include
-        |-- wasm32-unknown-emscripten
-            |-- bin
-            |-- lib
         |-- x86_64-linux-gnu
             |-- bin
             |-- lib

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

@@ -1,24 +1,30 @@
 import fs from "fs";
 import os from "os";
+import path from "path";
 import Config from "../src/Config";
 
 const home = os.homedir();
 const prefix = home + "/the-seed";
-const configDir = "./ConfigTestDir";
+
+function createTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "config-test-"));
+}
 
 describe("test Config", () => {
+  let configDir: string;
+  let config: Config;
+
   beforeAll(() => {
-    fs.mkdirSync(configDir);
+    configDir = createTempDir();
+    config = new Config(configDir);
   });
 
-  const config = new Config(configDir);
-
   it("write empty config file", () => {
     config.saveConfig();
   });
 
   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()
+      );
+    });
+  });
+});