purus 0.0.3 → 0.2.0

package/README-ja.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-[![Logo](./logo.png)](https://purus.work)
+[![Logo](https://raw.githubusercontent.com/otoneko1102/purus/refs/heads/main/logo.png)](https://purus.work)
 
 [English](https://raw.githubusercontent.com/otoneko1102/purus/refs/heads/main/README.md) | **日本語**
 
@@ -55,4 +55,4 @@ otoneko. https://github.com/otoneko1102
 
 ## ライセンス
 
-Apache 2.0 ライセンスに基づいて配布されます。詳細については、[LICENSE](./LICENSE) を参照してください。
+Apache 2.0 ライセンスに基づいて配布されます。詳細については、[LICENSE](https://raw.githubusercontent.com/otoneko1102/purus/refs/heads/main/LICENSE) を参照してください。

package/README.md

@@ -55,4 +55,4 @@ otoneko. https://github.com/otoneko1102
 
 ## License
 
-Distributed under the Apache 2.0 License. See [LICENSE](./LICENSE) for more information.
+Distributed under the Apache 2.0 License. See [LICENSE](https://raw.githubusercontent.com/otoneko1102/purus/refs/heads/main/LICENSE) for more information.

package/bin/purus.js

@@ -1,3 +1,52 @@
 #!/usr/bin/env node
 "use strict";
-require("../lib/purus-compiler.js");
+
+const VERSION = require("../package.json").version;
+const cmd = process.argv[2];
+
+function printHelp() {
+  console.log(`purus v${VERSION} - A language that compiles to JavaScript`);
+  console.log("");
+  console.log("Usage:");
+  console.log("  purus build [file]                  Compile to JavaScript");
+  console.log("  purus build --directory <dir>        Compile all files in directory");
+  console.log("  purus build --output <dir>           Specify output directory");
+  console.log("  purus build                          Compile using config.purus");
+  console.log("    .purus  -> .js");
+  console.log("    .cpurus -> .cjs (CommonJS)");
+  console.log("    .mpurus -> .mjs (ES Module)");
+  console.log("  purus build --no-header [file]       Compile without header comment");
+  console.log("  purus run [file]                     Run without generating files");
+  console.log("  purus run --directory <dir>           Run all files in directory");
+  console.log("  purus run                            Run using config.purus");
+  console.log("  purus check <file>                   Syntax check only");
+  console.log("  purus new [name] [-y]                Create a new project");
+  console.log("  purus init                           Initialize project in current directory");
+  console.log("  purus version                        Show version");
+  console.log("  purus help                           Show this help");
+  console.log("");
+  console.log("Aliases: compile = build, create = new");
+}
+
+switch (cmd) {
+  case "new":
+  case "create":
+    require("../lib/create.js");
+    break;
+  case "build":
+  case "compile":
+    require("../lib/build-wrapper.js");
+    break;
+  case "run":
+    require("../lib/run-wrapper.js");
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+  case undefined:
+    printHelp();
+    break;
+  default:
+    require("../lib/purus-compiler.js");
+    break;
+}

package/lib/build-wrapper.js

@@ -0,0 +1,142 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { loadConfig } = require("./config.js");
+const { compile } = require("./purus-core.js");
+
+const args = process.argv.slice(3);
+
+let file = null;
+let directory = null;
+let output = null;
+let noHeader = false;
+let toStdout = false;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--no-header") {
+    noHeader = true;
+  } else if (args[i] === "--stdout") {
+    toStdout = true;
+  } else if (args[i] === "--directory" || args[i] === "-d") {
+    directory = args[++i];
+  } else if (args[i] === "--output" || args[i] === "-o") {
+    output = args[++i];
+  } else if (!args[i].startsWith("-")) {
+    file = args[i];
+  }
+}
+
+if (file) {
+  // Single file - delegate to MoonBit compiler
+  require("./purus-compiler.js");
+} else {
+  let entryDir;
+  let outputDir;
+  let useHeader;
+
+  if (directory) {
+    entryDir = path.resolve(directory);
+    outputDir = output ? path.resolve(output) : path.resolve("dist");
+    useHeader = !noHeader;
+
+    const result = loadConfig();
+    if (result) {
+      if (!output) {
+        outputDir = path.resolve(
+          result.configDir,
+          result.config.output || "dist"
+        );
+      }
+      useHeader = result.config.header !== false && !noHeader;
+    }
+  } else {
+    const result = loadConfig();
+    if (!result) {
+      console.log("Error: no input file specified and no config.purus found");
+      console.log("");
+      console.log("Usage:");
+      console.log("  purus build <file>              Compile a single file");
+      console.log(
+        "  purus build --directory <dir>   Compile all files in directory"
+      );
+      console.log(
+        "  purus build                     Compile using config.purus"
+      );
+      process.exit(1);
+    }
+
+    const { config, configDir } = result;
+    entryDir = path.resolve(configDir, config.entry || "src");
+    outputDir = output
+      ? path.resolve(output)
+      : path.resolve(configDir, config.output || "dist");
+    useHeader = config.header !== false && !noHeader;
+  }
+
+  if (!fs.existsSync(entryDir)) {
+    console.log(`Error: entry directory '${entryDir}' not found`);
+    process.exit(1);
+  }
+
+  const stat = fs.statSync(entryDir);
+  let files;
+
+  if (stat.isFile()) {
+    files = [entryDir];
+    // For single file entry, output is a file too
+    if (!fs.existsSync(path.dirname(outputDir))) {
+      fs.mkdirSync(path.dirname(outputDir), { recursive: true });
+    }
+  } else {
+    files = findPurusFiles(entryDir);
+  }
+
+  if (files.length === 0) {
+    console.log(`No .purus files found in ${entryDir}`);
+    process.exit(0);
+  }
+
+  let count = 0;
+  for (const f of files) {
+    const source = fs.readFileSync(f, "utf8");
+    const js = compile(source, { header: useHeader });
+    let outputPath;
+
+    if (stat.isFile()) {
+      outputPath = outputDir;
+    } else {
+      outputPath = getOutputPath(f, entryDir, outputDir);
+    }
+
+    fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+    fs.writeFileSync(outputPath, js);
+    console.log(
+      `Compiled ${path.relative(process.cwd(), f)} -> ${path.relative(process.cwd(), outputPath)}`
+    );
+    count++;
+  }
+  console.log(`\n${count} file${count === 1 ? "" : "s"} compiled.`);
+}
+
+function findPurusFiles(dir) {
+  const results = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findPurusFiles(fullPath));
+    } else if (/\.(c|m)?purus$/.test(entry.name)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+function getOutputPath(inputFile, inputBase, outputBase) {
+  const relative = path.relative(inputBase, inputFile);
+  let ext = ".js";
+  if (inputFile.endsWith(".cpurus")) ext = ".cjs";
+  else if (inputFile.endsWith(".mpurus")) ext = ".mjs";
+  const base = relative.replace(/\.(c|m)?purus$/, "");
+  return path.join(outputBase, base + ext);
+}

package/lib/config.js

@@ -0,0 +1,67 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function parseConfig(configPath) {
+  const content = fs.readFileSync(configPath, "utf8");
+  const config = {};
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("--")) continue;
+
+    const match = trimmed.match(/^const\s+([\w.-]+)\s+be\s+(.+)$/);
+    if (!match) continue;
+
+    const key = match[1];
+    let value = match[2].trim();
+
+    if (value.startsWith("///") && value.endsWith("///")) {
+      value = value.slice(3, -3);
+    } else if (value === "true") {
+      value = true;
+    } else if (value === "false") {
+      value = false;
+    } else if (/^\d+$/.test(value)) {
+      value = parseInt(value, 10);
+    } else if (/^\d+\.\d+$/.test(value)) {
+      value = parseFloat(value);
+    }
+
+    const keys = key.split(".");
+    let target = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+      if (!target[keys[i]] || typeof target[keys[i]] !== "object") {
+        target[keys[i]] = {};
+      }
+      target = target[keys[i]];
+    }
+    target[keys[keys.length - 1]] = value;
+  }
+
+  return config;
+}
+
+function findConfig(startDir) {
+  let dir = startDir || process.cwd();
+  while (true) {
+    const configPath = path.join(dir, "config.purus");
+    if (fs.existsSync(configPath)) return configPath;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+function loadConfig(startDir) {
+  const configPath = findConfig(startDir);
+  if (!configPath) return null;
+  return {
+    config: parseConfig(configPath),
+    configPath,
+    configDir: path.dirname(configPath),
+  };
+}
+
+module.exports = { parseConfig, findConfig, loadConfig };

package/lib/create.js

@@ -0,0 +1,195 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const { spawnSync } = require("child_process");
+
+function question(rl, text) {
+  return new Promise((resolve) => rl.question(text, (a) => resolve(a.trim())));
+}
+
+function isDirEmpty(dir) {
+  return fs.readdirSync(dir).length === 0;
+}
+
+async function run() {
+  const args = process.argv.slice(3);
+  const yesFlag = args.includes("-y") || args.includes("--yes");
+  const positionalArgs = args.filter((a) => !a.startsWith("-"));
+
+  let projectName = positionalArgs[0] || "";
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    if (!projectName) {
+      projectName = await question(rl, "Project name: ");
+      if (!projectName) {
+        console.log("Error: project name required");
+        process.exit(1);
+      }
+    }
+
+    const projectDir = path.resolve(projectName);
+
+    if (fs.existsSync(projectDir) && !isDirEmpty(projectDir)) {
+      console.log(`Error: directory '${projectName}' already exists and is not empty`);
+      process.exit(1);
+    }
+
+    console.log(`\nCreating project in ./${projectName}...`);
+    fs.mkdirSync(path.join(projectDir, "src"), { recursive: true });
+
+    // config.purus
+    const configPurus = `-- Purus Configuration
+
+const entry be ///src///
+const output be ///dist///
+const header be true
+
+-- Linter settings
+const lint.no-var be ///warn///
+const lint.indent-size be 2
+const lint.max-line-length be ///off///
+`;
+    fs.writeFileSync(path.join(projectDir, "config.purus"), configPurus);
+
+    // .prettierrc
+    const prettierrc =
+      JSON.stringify(
+        {
+          tabWidth: 2,
+          semi: false,
+          plugins: ["@puruslang/prettier-plugin-purus"],
+        },
+        null,
+        2
+      ) + "\n";
+    fs.writeFileSync(path.join(projectDir, ".prettierrc"), prettierrc);
+
+    // src/main.purus
+    const mainPurus = `-- main.purus
+
+const message be ///Hello, World///
+console.log[message]
+`;
+    fs.writeFileSync(path.join(projectDir, "src/main.purus"), mainPurus);
+
+    // README.md
+    const readme = `# ${projectName}
+
+A [Purus](https://purus.work) project.
+
+## Getting Started
+
+\`\`\`sh
+npm install
+purus build
+\`\`\`
+
+## Scripts
+
+| Script | Description |
+|---|---|
+| \`npm run build\` | Compile Purus to JavaScript |
+| \`npm run exec\` | Run without compiling to files |
+| \`npm run format\` | Format with Prettier |
+| \`npm run lint\` | Lint with purus-lint |
+`;
+    fs.writeFileSync(path.join(projectDir, "README.md"), readme);
+
+    // .gitignore
+    const gitignore = `dist/
+node_modules/
+`;
+    fs.writeFileSync(path.join(projectDir, ".gitignore"), gitignore);
+
+    console.log("  config.purus");
+    console.log("  .prettierrc");
+    console.log("  .gitignore");
+    console.log("  README.md");
+    console.log("  src/main.purus");
+
+    // npm init
+    console.log("");
+    if (yesFlag) {
+      console.log("Running npm init -y...");
+      spawnSync("npm", ["init", "-y"], {
+        cwd: projectDir,
+        stdio: "inherit",
+        shell: true,
+      });
+    } else {
+      console.log("Running npm init...");
+      spawnSync("npm", ["init"], {
+        cwd: projectDir,
+        stdio: "inherit",
+        shell: true,
+      });
+    }
+
+    // Add scripts to package.json
+    const pkgPath = path.join(projectDir, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+      pkg.scripts = {
+        ...(pkg.scripts || {}),
+        purus: "purus",
+        build: "purus build",
+        compile: "purus compile",
+        exec: "purus run",
+        format: "prettier --write ./src",
+        lint: "purus-lint",
+      };
+      fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+      console.log("\nAdded scripts to package.json");
+    }
+
+    // Ask about dependencies
+    let installDeps;
+    if (yesFlag) {
+      installDeps = true;
+    } else {
+      const answer = await question(rl, "\nInstall dependencies? (y/N) ");
+      installDeps =
+        answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+    }
+
+    if (installDeps) {
+      const devDeps = [
+        "@puruslang/linter",
+        "@puruslang/prettier-plugin-purus",
+        "prettier",
+        "purus",
+      ];
+      console.log("\nInstalling devDependencies...");
+      for (const dep of devDeps) {
+        console.log(`  ${dep}`);
+      }
+      console.log("");
+      spawnSync("npm", ["install", "--save-dev", ...devDeps], {
+        cwd: projectDir,
+        stdio: "inherit",
+        shell: true,
+      });
+    }
+
+    console.log("\nDone! To get started:");
+    console.log(`  cd ${projectName}`);
+    if (!installDeps) {
+      console.log("  npm install");
+    }
+    console.log("  purus build");
+  } finally {
+    rl.close();
+  }
+}
+
+run().catch((err) => {
+  console.error(err.message);
+  process.exit(1);
+});