@jals1212/pi-spaces-cli 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -6,6 +6,57 @@ commands and options and a patch version fixes.
 
 ## Unreleased
 
+## 0.3.0
+
+### Added
+
+- `pi-space --new <name>` creates a space from the shell, with the same
+  `settings.json` as `/space new <name>`: the base home's declaration of
+  `@jals1212/pi-spaces`, or `npm:@jals1212/pi-spaces`. It does not start Pi.
+  A local path in the base home is copied when it is a copy of the extension.
+- `pi-space --remove <name>` deletes a space after asking in
+  the terminal, with the same safety checks as `/space remove`, then asks
+  whether to keep a backup in `.backups` (`[Y/n]`: Enter keeps one). `--yes`
+  skips the questions and keeps a backup, and is required without a terminal;
+  `--no-backup` deletes without one.
+- `--command <cmd>` and `--dir <path>`, before the rest of the arguments, set
+  the program to run and the spaces folder for one call, instead of
+  `PI_SPACES_COMMAND` and `PI_SPACES_DIR`. With `--dir`, the Pi it starts gets
+  that folder as `PI_SPACES_DIR`.
+- Quotes in `--command` and `PI_SPACES_COMMAND`: double or single quotes keep a
+  path with spaces in one word, as in `--command '"/opt/my launcher/run" --'`.
+  A quote that is never closed is an error (exit status 2) and starts nothing.
+
+### Changed
+
+- `pi-space list` with no spaces suggests `pi-space --new <name>`.
+- A `"` or `'` in `PI_SPACES_COMMAND` is now a quote, no longer part of a
+  word: a path with an apostrophe, such as `/home/o'neil/bin/run`, needs double
+  quotes around it.
+- Needs `@jals1212/pi-spaces` 0.2.0 or later (for `backupSpace` and the
+  local-path rule of `--new`).
+
+### Fixed
+
+- `pi-space --new` copies the base home's local path to this checkout of the
+  extension instead of writing `npm:@jals1212/pi-spaces`.
+- `pi-space --remove` explains a backup that cannot be written (for example a
+  read-only spaces folder): the space was not removed, and `--no-backup`
+  removes it without one.
+- A program whose path has spaces now starts, including on Windows, where
+  cmd.exe runs it and each word is now quoted for it.
+
+## 0.2.0
+
+### Added
+
+- `pi-space --version` (or `-v`) prints the version.
+
+### Fixed
+
+- An unknown option such as `--bogus` in first place is reported as an unknown
+  option with the usage, exit code 2, instead of as an invalid space name.
+
 ## 0.1.0
 
 ### Added

package/README.md

@@ -17,11 +17,28 @@ Node 20 or later. The Pi extension `@jals1212/pi-spaces` must be installed in th
 | `pi-space` | Shows a numbered list of spaces and starts Pi in the one you pick. |
 | `pi-space <name> [pi args...]` | Starts Pi in that space (`base` for the home Pi starts with). |
 | `pi-space list` | Lists the spaces. A space named `list` can still be opened from the picker. |
+| `pi-space --new <name>` | Creates an empty space, as `/space new <name>` does in Pi. It does not start Pi. |
+| `pi-space --remove <name> [--yes] [--no-backup]` | Deletes a space, as `/space remove <name>` does in Pi. It asks first (`[y/N]`), then whether to keep a backup in `<spaces folder>/.backups` (`[Y/n]`: Enter keeps one). `--yes` skips the questions and keeps a backup, and is required without a terminal; `--no-backup` deletes without one. |
 | `pi-space --help` | Shows the usage. |
+| `pi-space --version` | Prints the version. |
+
+A new space gets a `settings.json` that declares the extension, so `/space` works inside it: the same declaration as in the base home's `settings.json` (`PI_SPACES_BASE_HOME`, else `PI_CODING_AGENT_DIR`, else `~/.pi/agent`), or `npm:@jals1212/pi-spaces` when the base home does not declare it. A local path counts when it is a copy of the extension: a folder whose `package.json` is named `@jals1212/pi-spaces`.
+
+`--remove` refuses `base`, the space you are in, a space that holds the base home, and anything that is not a real folder inside the spaces folder, before it asks. A backup is the whole space folder, moved to `.backups/<name>-<UTC time>`; move it back to restore it. See [what it leaves on your machine](https://github.com/jals1212/pi-spaces#what-it-leaves-on-your-machine).
 
 ## Another program that runs Pi
 
-To start Pi through another program, set `PI_SPACES_COMMAND` in your shell profile; its words come before `--space`. Such a program usually has its own home, so point `PI_SPACES_DIR` at its spaces folder too, so `pi-space` lists the same spaces:
+To start Pi through another program for one call, give `--command` and `--dir` before the rest; the words of `--command` come before `--space`. The words are split on spaces; double or single quotes keep a path with spaces in one word. Such a program usually has its own home, so `--dir` points at its spaces folder, and the Pi it starts gets that folder as `PI_SPACES_DIR` too. Nothing is exported, so a plain `pi` in the same shell is not affected:
+
+```sh
+pi-space --command "my-launcher --" --dir ~/.my-launcher/spaces work   # → my-launcher -- --space work
+pi-space --dir ~/.my-launcher/spaces --new work                         # create one in that folder
+pi-space --command '"/opt/my launcher/run" --' work                     # a path with spaces, in quotes
+```
+
+Inside quotes a backslash is a plain character, so `"C:\Program Files\my-launcher\run.cmd"` works as written. A quote that is never closed is an error (exit status 2), and nothing is started.
+
+An alias keeps it short: `alias my-space='pi-space --command "my-launcher --" --dir ~/.my-launcher/spaces'`. To make it the default instead, set the variables in your shell profile:
 
 ```sh
 export PI_SPACES_COMMAND="my-launcher --"    # pi-space work → my-launcher -- --space work
@@ -30,8 +47,8 @@ export PI_SPACES_DIR=~/.my-launcher/spaces   # the spaces next to that program's
 
 | Variable | Meaning |
 | --- | --- |
-| `PI_SPACES_COMMAND` | The program to run, split on spaces, before `--space <name>`. Default: `pi`. |
-| `PI_SPACES_DIR` | The spaces folder. A relative value is taken from your home folder. Default: `spaces` next to the base home. |
+| `PI_SPACES_COMMAND` | The program to run, split on spaces (double or single quotes keep a path with spaces in one word, as in `"/opt/my launcher/run" --`), before `--space <name>`. Default: `pi`. `--command` wins for one call. |
+| `PI_SPACES_DIR` | The spaces folder. A relative value is taken from your home folder. Default: `spaces` next to the base home. `--dir` wins for one call; a relative `--dir` is taken from the current folder. |
 | `PI_CODING_AGENT_DIR` | Pi's agent home; its parent holds the default spaces folder. Default: `~/.pi/agent`. |
 
 ## Exit status
@@ -39,8 +56,8 @@ export PI_SPACES_DIR=~/.my-launcher/spaces   # the spaces next to that program's
 | Status | Meaning |
 | --- | --- |
 | 0 … | Pi's own exit status. |
-| 1 | An unknown or invalid space, an out-of-range pick, or the program could not start. |
-| 2 | No arguments and no terminal to pick in: the usage is printed. |
+| 1 | An unknown or invalid space, a name `--new` cannot use (taken, `base` or invalid), a space `--remove` cannot delete, `--remove` without `--yes` and no terminal, an out-of-range pick, or the program could not start. |
+| 2 | No arguments and no terminal to pick in, `--new` or `--remove` without exactly one name, or `--command` or `--dir` without a value or given twice: the usage is printed. A `--command` or `PI_SPACES_COMMAND` with an unclosed quote: the problem is printed. |
 
 ## More
 

package/dist/cli.js

@@ -1,39 +1,182 @@
 // The optional `pi-space` command: pick a space and start Pi in it.
 // It only passes `--space <name>`; the extension does the switch, so it never sets PI_CODING_AGENT_DIR.
 import { spawn as nodeSpawn } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
-import { BASE,           listSpaces, spacesDir, validateName } from "@jals1212/pi-spaces/spaces";
+import { fileURLToPath } from "node:url";
+import {
+	BACKUPS,
+	BASE,
+	backupSpace,
+	checkRemovable,
+	createSpace,
+	         
+	findOwnDeclaration,
+	listSpaces,
+	                        
+	removeSpace,
+	SpaceError,
+	spacesDir,
+	validateName,
+} from "@jals1212/pi-spaces/spaces";
 
-export const USAGE = `Usage: pi-space [<name> [pi args...] | list | --help]
-  pi-space              pick a space and start Pi in it
-  pi-space <name> ...   start Pi in a space ("base" for the home Pi starts with)
-  pi-space list         list the spaces
-PI_SPACES_COMMAND sets the program to run (default: pi), e.g. "my-launcher --".
+export const USAGE = `Usage: pi-space [--command <cmd>] [--dir <path>] [<name> [pi args...] | list | --new <name> | --remove <name> [--yes] [--no-backup]]
+       pi-space --help | --version
+  pi-space                   pick a space and start Pi in it
+  pi-space <name> ...        start Pi in a space ("base" for the home Pi starts with)
+  pi-space list              list the spaces
+  pi-space --new <name>      create a space
+  pi-space --remove <name>   delete a space and everything in it, after asking, and keep a backup in .backups unless told not to
+                             (--yes skips the questions; --no-backup deletes without a backup)
+  pi-space --version         print the version
+Options for this call only:
+  --command <cmd>            the program to run instead of $PI_SPACES_COMMAND (default: pi), e.g. "my-launcher --"
+  --dir <path>               the spaces folder instead of $PI_SPACES_DIR; the Pi it starts gets it too
 `;
 
-                        
+/** This package's version; package.json sits one folder above both src/ and dist/. */
+export const VERSION         = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+
+/** --command and --dir: for this call only, so nothing has to be exported into the shell. */
+                              
+	                 
+	             
+ 
+
+                          
 	                  
+	                     
+	                                            
 	                  
+	                               
+	                                                                 
 	                    
 	                   
-	                                                   
+	                                                  
+   
+	            
+
+const CALL_OPTIONS = { "--command": "command", "--dir": "dir" }         ;
 
-/** `list` is the subcommand, so a space named "list" can only be opened from the picker. */
+/**
+ * --command and --dir come first; after a space name every argument belongs to Pi.
+ * `list` is the subcommand, so a space named "list" can only be opened from the picker.
+ * `--new` and `--remove` are options, not subcommands, so they never take a space name.
+ * A space name never starts with "-", so any other option in first place is unknown, not a name.
+ */
 export function parseCli(args          )             {
+	const options              = {};
+	let index = 0;
+	while (Object.hasOwn(CALL_OPTIONS, args[index] ?? "")) {
+		const key = CALL_OPTIONS[args[index]                             ];
+		const value = args[index + 1];
+		if (!value || options[key] !== undefined) return { kind: "usage" };
+		options[key] = value;
+		index += 2;
+	}
+	const command = parseCommand(args.slice(index));
+	return command.kind === "usage" ? command : { ...command, ...options };
+}
+
+function parseCommand(args          )             {
 	const [first, ...rest] = args;
 	if (first === undefined) return { kind: "picker" };
 	if (first === "--help" || first === "-h") return { kind: "help" };
+	if (first === "--version" || first === "-v") return { kind: "version" };
+	if (first === "--new") return rest.length === 1 ? { kind: "new", name: rest[0] } : { kind: "usage" };
+	if (first === "--remove") {
+		const flags = rest.filter((arg) => arg.startsWith("-"));
+		const names = rest.filter((arg) => !arg.startsWith("-"));
+		const yes = flags.filter((flag) => flag === "--yes" || flag === "-y").length;
+		const noBackup = flags.filter((flag) => flag === "--no-backup").length;
+		if (names.length !== 1 || yes > 1 || noBackup > 1 || yes + noBackup !== flags.length) return { kind: "usage" };
+		return { kind: "remove", name: names[0], yes: yes === 1, backup: noBackup === 0 };
+	}
+	if (first.startsWith("-")) return { kind: "unknown-option", option: first };
 	if (first === "list") return rest.length === 0 ? { kind: "list" } : { kind: "usage" };
 	return { kind: "launch", name: first, args: rest };
 }
 
-/** The program and arguments that start Pi in a space: $PI_SPACES_COMMAND (default pi) plus --space <name>. */
+/**
+ * The program and arguments that start Pi in a space: $PI_SPACES_COMMAND (default pi) plus --space <name>.
+ * Throws when the command has an unclosed quote.
+ */
 export function launchCommand(env     , name        , args          )                                      {
-	const [program = "pi", ...prefix] = (env.PI_SPACES_COMMAND ?? "").split(/\s+/).filter(Boolean);
+	const [program = "pi", ...prefix] = splitCommand(env.PI_SPACES_COMMAND ?? "");
 	return { program, args: [...prefix, "--space", name, ...args] };
 }
 
+/**
+ * Splits a command into words on whitespace. Double or single quotes keep whitespace inside a word and are
+ * removed. There are no backslash escapes, so a Windows path in quotes keeps its backslashes.
+ */
+export function splitCommand(text        )           {
+	const words           = [];
+	let word = "";
+	// True from the first character or quote of a word, so "" alone is an empty word.
+	let started = false;
+	let quote                    ;
+	for (const char of text) {
+		if (quote) {
+			if (char === quote) quote = undefined;
+			else word += char;
+		} else if (char === '"' || char === "'") {
+			quote = char;
+			started = true;
+		} else if (/\s/.test(char)) {
+			if (started) words.push(word);
+			word = "";
+			started = false;
+		} else {
+			word += char;
+			started = true;
+		}
+	}
+	if (quote) throw new Error(`the command has an unclosed ${quote} quote`);
+	if (started) words.push(word);
+	return words;
+}
+
+/**
+ * One word for the single command line cmd.exe gets when the child runs with shell: true on Windows:
+ * wrapped in double quotes unless it is plain, with inner double quotes doubled.
+ */
+export function quoteForCmd(word        )         {
+	if (word !== "" && !/[\s"&|<>^()%!,;=]/.test(word)) return word;
+	return `"${word.replaceAll('"', '""')}"`;
+}
+
+const EXTENSION = "@jals1212/pi-spaces";
+
+/**
+ * The extension's declaration for a new space's settings.json: the one in the base home's settings.json
+ * (PI_SPACES_BASE_HOME, else PI_CODING_AGENT_DIR, else ~/.pi/agent), else npm:@jals1212/pi-spaces.
+ */
+export function newSpaceDeclaration(env     , home        )                     {
+	const baseHome = env.PI_SPACES_BASE_HOME || agentHome(env, home);
+	let packageRoot        ;
+	try {
+		packageRoot = dirname(fileURLToPath(import.meta.resolve(`${EXTENSION}/package.json`)));
+	} catch {
+		packageRoot = "";
+	}
+	return findOwnDeclaration(baseHome, EXTENSION, packageRoot, `npm:${EXTENSION}`);
+}
+
+/** The agent home Pi uses from this shell: PI_CODING_AGENT_DIR, else ~/.pi/agent. */
+function agentHome(env     , home        )         {
+	return env.PI_CODING_AGENT_DIR ? env.PI_CODING_AGENT_DIR.replace(/^~(?=\/|$)/, home) : join(home, ".pi", "agent");
+}
+
+                               
+	                 
+	               
+	                                                                                              
+	          
+ 
+
                               
 	                      
 	              
@@ -44,13 +187,17 @@ export function launchCommand(env     , name        , args          )
 	                                         
 	                                         
 	         
+	                                                                                                    
+	               
 	             
-	                                                                                                            
+	                                                                
+	                           
+	                                                                                    
 	                         
  
 
 /** The real child process: stdio inherited, the environment unchanged, a shell on Windows so .cmd shims work. */
-export function spawnChild(program        , args          , options                                      )                       {
+export function spawnChild(program        , args          , options              )                       {
 	// Ctrl-C belongs to Pi while it runs; this process waits for it instead of dying first.
 	const ignore = () => {};
 	process.on("SIGINT", ignore);
@@ -69,36 +216,147 @@ export function processIo(proc                 = process)        {
 		stderr: proc.stderr,
 		env: proc.env,
 		home: homedir(),
+		platform: process.platform,
 		spawn: spawnChild,
 		exit: (code) => proc.exit(code),
 	};
 }
 
 export async function main(argv          , io       )                {
-	const dir = spacesDir(io.env, io.home);
 	const command = parseCli(argv);
+	if (command.dir !== undefined || command.command !== undefined) {
+		// A relative --dir is relative to where the command runs; the child gets it absolute.
+		const env = { ...io.env };
+		if (command.dir !== undefined) env.PI_SPACES_DIR = resolve(command.dir);
+		if (command.command !== undefined) env.PI_SPACES_COMMAND = command.command;
+		io = { ...io, env, childEnv: command.dir !== undefined ? { ...io.env, PI_SPACES_DIR: env.PI_SPACES_DIR } : undefined };
+	}
+	const commandSource = command.command !== undefined ? "--command" : "PI_SPACES_COMMAND";
+	const dir = spacesDir(io.env, io.home);
 	switch (command.kind) {
 		case "help":
 			io.stdout.write(USAGE);
 			return io.exit(0);
+		case "version":
+			io.stdout.write(`${VERSION}\n`);
+			return io.exit(0);
+		case "unknown-option":
+			io.stderr.write(`pi-space: Unknown option "${command.option}".\n${USAGE}`);
+			return io.exit(2);
 		case "usage":
 			io.stderr.write(USAGE);
 			return io.exit(2);
 		case "list": {
 			const spaces = listSpaces(dir);
 			const lines = [`Spaces in ${dir}:`, `  ${BASE}`, ...spaces.map((name) => `  ${name}`)];
-			if (spaces.length === 0) lines.push("No spaces yet. Create one with /space new <name> inside Pi.");
+			if (spaces.length === 0) lines.push("No spaces yet. Create one with pi-space --new <name>.");
 			io.stdout.write(`${lines.join("\n")}\n`);
 			return io.exit(0);
 		}
+		case "new":
+			return create(command.name, dir, io);
+		case "remove":
+			return remove(command.name, command.yes, command.backup, dir, io);
 		case "launch":
-			return launch(command.name, command.args, dir, io);
+			return launch(command.name, command.args, dir, io, commandSource);
 		case "picker":
-			return pick(dir, io);
+			return pick(dir, io, commandSource);
+	}
+}
+
+function create(name        , dir        , io       )       {
+	try {
+		const path = createSpace(dir, name, newSpaceDeclaration(io.env, io.home));
+		io.stdout.write(`Created space "${name}" at ${path}.\nStart Pi in it with: pi-space ${name}\n`);
+		return io.exit(0);
+	} catch (error) {
+		// A SpaceError is a rule (a bad or taken name); anything else is the filesystem, such as no permission.
+		io.stderr.write(`pi-space: ${error instanceof SpaceError ? error.message : `could not create space "${name}": ${(error         ).message}`}\n`);
+		return io.exit(1);
+	}
+}
+
+/**
+ * Without --yes it asks to remove ([y/N]), then, without --no-backup, whether to keep a backup ([Y/n]).
+ * With --yes it asks nothing and keeps a backup unless --no-backup.
+ */
+async function remove(name        , yes         , backup         , dir        , io       )                {
+	const current = agentHome(io.env, io.home);
+	const protect = io.env.PI_SPACES_BASE_HOME ? [io.env.PI_SPACES_BASE_HOME] : [];
+	let reader                        ;
+	try {
+		// Fail before asking when the space cannot be removed anyway.
+		const path = checkRemovable(dir, name, current, protect, io.home);
+		let keep = backup;
+		if (!yes) {
+			if (!io.stdin.isTTY) throw new SpaceError(`Removing a space needs confirmation; run pi-space --remove ${name} --yes.`);
+			// One reader for every question, so an answer typed ahead is not lost between them.
+			reader = lineReader(io.stdin);
+			io.stdout.write(`Remove space "${name}"? This deletes ${path} and everything in it: sign-ins, packages, settings and sessions. [y/N] `);
+			if (!isYes(await reader.next())) {
+				io.stdout.write(`Kept space "${name}".\n`);
+				return io.exit(0);
+			}
+			if (backup) {
+				io.stdout.write(`Keep a backup of "${name}" in ${join(dir, BACKUPS)}? [Y/n] `);
+				// Only a clear no skips the backup: Enter or the end of input keep one.
+				const answer = (await reader.next())?.trim().toLowerCase();
+				keep = answer !== "n" && answer !== "no";
+			}
+		}
+		if (keep) {
+			const saved = backupSpace(dir, name, current, protect, io.home);
+			io.stdout.write(`Removed space "${name}"; its backup is ${saved}.\n`);
+		} else {
+			removeSpace(dir, name, current, protect, io.home);
+			io.stdout.write(`Removed space "${name}".\n`);
+		}
+		return io.exit(0);
+	} catch (error) {
+		io.stderr.write(`pi-space: ${error instanceof SpaceError ? error.message : `could not remove space "${name}": ${(error         ).message}`}\n`);
+		return io.exit(1);
+	} finally {
+		reader?.close();
 	}
 }
 
-async function launch(name        , args          , dir        , io       )                {
+function isYes(answer                    )          {
+	const word = answer?.trim().toLowerCase();
+	return word === "y" || word === "yes";
+}
+
+                      
+	                                                   
+	                                    
+	              
+ 
+
+/** Reads lines one at a time from one readline interface, keeping lines that arrive before they are asked for. */
+function lineReader(input                       )             {
+	const rl = createInterface({ input });
+	const lines           = [];
+	const waiting                                         = [];
+	let ended = false;
+	rl.on("line", (line) => {
+		const resolve = waiting.shift();
+		if (resolve) resolve(line);
+		else lines.push(line);
+	});
+	rl.once("close", () => {
+		ended = true;
+		for (const resolve of waiting.splice(0)) resolve(undefined);
+	});
+	return {
+		next: () => {
+			if (lines.length > 0) return Promise.resolve(lines.shift());
+			if (ended) return Promise.resolve(undefined);
+			return new Promise((resolve) => waiting.push(resolve));
+		},
+		close: () => rl.close(),
+	};
+}
+
+async function launch(name        , args          , dir        , io       , commandSource        )                {
 	if (name !== BASE) {
 		const invalid = validateName(name);
 		if (invalid) {
@@ -110,8 +368,21 @@ async function launch(name        , args          , dir        , io       )
 			return io.exit(1);
 		}
 	}
-	const { program, args: programArgs } = launchCommand(io.env, name, args);
-	const result = await io.spawn(program, programArgs, { stdio: "inherit", shell: process.platform === "win32" });
+	let launched                                     ;
+	try {
+		launched = launchCommand(io.env, name, args);
+	} catch (error) {
+		io.stderr.write(`pi-space: ${commandSource}: ${(error         ).message}.\n`);
+		return io.exit(2);
+	}
+	const { program, args: programArgs } = launched;
+	const windows = (io.platform ?? process.platform) === "win32";
+	const options               = { stdio: "inherit", shell: windows };
+	if (io.childEnv) options.env = io.childEnv;
+	// With a shell, Node joins the program and arguments into one line without quoting them.
+	const result = windows
+		? await io.spawn(quoteForCmd(program), programArgs.map(quoteForCmd), options)
+		: await io.spawn(program, programArgs, options);
 	if (result.error) {
 		io.stderr.write(`pi-space: could not start ${program}: ${result.error.message}\n`);
 		return io.exit(1);
@@ -119,7 +390,7 @@ async function launch(name        , args          , dir        , io       )
 	io.exit(result.status ?? 1);
 }
 
-async function pick(dir        , io       )                {
+async function pick(dir        , io       , commandSource        )                {
 	if (!io.stdin.isTTY) {
 		io.stderr.write(USAGE);
 		return io.exit(2);
@@ -134,7 +405,7 @@ async function pick(dir        , io       )                {
 		io.stderr.write(`pi-space: Choose a number from 1 to ${names.length}.\n`);
 		return io.exit(1);
 	}
-	return launch(names[number - 1], [], dir, io);
+	return launch(names[number - 1], [], dir, io, commandSource);
 }
 
 /** One line from the stream, or undefined at end of input. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jals1212/pi-spaces-cli",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "The pi-space command: pick a space and start Pi in it. Companion to the Pi extension @jals1212/pi-spaces.",
   "license": "MIT",
   "author": "jals1212",
@@ -38,7 +38,7 @@
     "test": "node ../scripts/link-self.mjs && npm run build --prefix .. && npm run build && node --test 'test/*.test.ts'"
   },
   "dependencies": {
-    "@jals1212/pi-spaces": "^0.1.1"
+    "@jals1212/pi-spaces": "^0.2.0"
   },
   "publishConfig": {
     "access": "public",