@seyuna/cli 1.0.0-canary.23 → 1.0.0-canary.25

package/esm/deps/jsr.io/@std/path/1.1.4/windows/resolve.js

@@ -0,0 +1,154 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import * as dntShim from "../../../../../../_dnt.shims.js";
+import { CHAR_COLON } from "../_common/constants.js";
+import { normalizeString } from "../_common/normalize_string.js";
+import { assertPath } from "../_common/assert_path.js";
+import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
+/**
+ * Resolves path segments into a `path`.
+ *
+ * @example Usage
+ * ```ts
+ * import { resolve } from "@std/path/windows/resolve";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const resolved = resolve("C:\\foo\\bar", "..\\baz");
+ * assertEquals(resolved, "C:\\foo\\baz");
+ * ```
+ *
+ * @param pathSegments The path segments to process to path
+ * @returns The resolved path
+ */
+export function resolve(...pathSegments) {
+    let resolvedDevice = "";
+    let resolvedTail = "";
+    let resolvedAbsolute = false;
+    for (let i = pathSegments.length - 1; i >= -1; i--) {
+        let path;
+        // deno-lint-ignore no-explicit-any
+        const { Deno } = dntShim.dntGlobalThis;
+        if (i >= 0) {
+            path = pathSegments[i];
+        }
+        else if (!resolvedDevice) {
+            if (typeof Deno?.cwd !== "function") {
+                throw new TypeError("Resolved a drive-letter-less path without a current working directory (CWD)");
+            }
+            path = Deno.cwd();
+        }
+        else {
+            if (typeof Deno?.env?.get !== "function" || typeof Deno?.cwd !== "function") {
+                throw new TypeError("Resolved a relative path without a current working directory (CWD)");
+            }
+            path = Deno.cwd();
+            // Verify that a cwd was found and that it actually points
+            // to our drive. If not, default to the drive's root.
+            if (path === undefined ||
+                path.slice(0, 3).toLowerCase() !== `${resolvedDevice.toLowerCase()}\\`) {
+                path = `${resolvedDevice}\\`;
+            }
+        }
+        assertPath(path);
+        const len = path.length;
+        // Skip empty entries
+        if (len === 0)
+            continue;
+        let rootEnd = 0;
+        let device = "";
+        let isAbsolute = false;
+        const code = path.charCodeAt(0);
+        // Try to match a root
+        if (len > 1) {
+            if (isPathSeparator(code)) {
+                // Possible UNC root
+                // If we started with a separator, we know we at least have an
+                // absolute path of some kind (UNC or otherwise)
+                isAbsolute = true;
+                if (isPathSeparator(path.charCodeAt(1))) {
+                    // Matched double path separator at beginning
+                    let j = 2;
+                    let last = j;
+                    // Match 1 or more non-path separators
+                    for (; j < len; ++j) {
+                        if (isPathSeparator(path.charCodeAt(j)))
+                            break;
+                    }
+                    if (j < len && j !== last) {
+                        const firstPart = path.slice(last, j);
+                        // Matched!
+                        last = j;
+                        // Match 1 or more path separators
+                        for (; j < len; ++j) {
+                            if (!isPathSeparator(path.charCodeAt(j)))
+                                break;
+                        }
+                        if (j < len && j !== last) {
+                            // Matched!
+                            last = j;
+                            // Match 1 or more non-path separators
+                            for (; j < len; ++j) {
+                                if (isPathSeparator(path.charCodeAt(j)))
+                                    break;
+                            }
+                            if (j === len) {
+                                // We matched a UNC root only
+                                device = `\\\\${firstPart}\\${path.slice(last)}`;
+                                rootEnd = j;
+                            }
+                            else if (j !== last) {
+                                // We matched a UNC root with leftovers
+                                device = `\\\\${firstPart}\\${path.slice(last, j)}`;
+                                rootEnd = j;
+                            }
+                        }
+                    }
+                }
+                else {
+                    rootEnd = 1;
+                }
+            }
+            else if (isWindowsDeviceRoot(code)) {
+                // Possible device root
+                if (path.charCodeAt(1) === CHAR_COLON) {
+                    device = path.slice(0, 2);
+                    rootEnd = 2;
+                    if (len > 2) {
+                        if (isPathSeparator(path.charCodeAt(2))) {
+                            // Treat separator following drive name as an absolute path
+                            // indicator
+                            isAbsolute = true;
+                            rootEnd = 3;
+                        }
+                    }
+                }
+            }
+        }
+        else if (isPathSeparator(code)) {
+            // `path` contains just a path separator
+            rootEnd = 1;
+            isAbsolute = true;
+        }
+        if (device.length > 0 &&
+            resolvedDevice.length > 0 &&
+            device.toLowerCase() !== resolvedDevice.toLowerCase()) {
+            // This path points to another device so it is not applicable
+            continue;
+        }
+        if (resolvedDevice.length === 0 && device.length > 0) {
+            resolvedDevice = device;
+        }
+        if (!resolvedAbsolute) {
+            resolvedTail = `${path.slice(rootEnd)}\\${resolvedTail}`;
+            resolvedAbsolute = isAbsolute;
+        }
+        if (resolvedAbsolute && resolvedDevice.length > 0)
+            break;
+    }
+    // At this point the path should be resolved to a full absolute path,
+    // but handle relative paths to be safe (might happen when Deno.cwd()
+    // fails)
+    // Normalize the tail path
+    resolvedTail = normalizeString(resolvedTail, !resolvedAbsolute, "\\", isPathSeparator);
+    return resolvedDevice + (resolvedAbsolute ? "\\" : "") + resolvedTail || ".";
+}

package/esm/deps/jsr.io/@std/path/1.1.4/windows/to_file_url.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "@std/path/windows/to-file-url";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
+ * assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
+ * assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
+ * ```
+ * @param path The path to convert.
+ * @returns The file URL.
+ */
+export declare function toFileUrl(path: string): URL;
+//# sourceMappingURL=to_file_url.d.ts.map

package/esm/deps/jsr.io/@std/path/1.1.4/windows/to_file_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_file_url.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/to_file_url.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAgB3C"}

package/esm/deps/jsr.io/@std/path/1.1.4/windows/to_file_url.js

@@ -0,0 +1,34 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { encodeWhitespace } from "../_common/to_file_url.js";
+import { isAbsolute } from "./is_absolute.js";
+/**
+ * Converts a path string to a file URL.
+ *
+ * @example Usage
+ * ```ts
+ * import { toFileUrl } from "@std/path/windows/to-file-url";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(toFileUrl("\\home\\foo"), new URL("file:///home/foo"));
+ * assertEquals(toFileUrl("C:\\Users\\foo"), new URL("file:///C:/Users/foo"));
+ * assertEquals(toFileUrl("\\\\127.0.0.1\\home\\foo"), new URL("file://127.0.0.1/home/foo"));
+ * ```
+ * @param path The path to convert.
+ * @returns The file URL.
+ */
+export function toFileUrl(path) {
+    if (!isAbsolute(path)) {
+        throw new TypeError(`Path must be absolute: received "${path}"`);
+    }
+    const [, hostname, pathname] = path.match(/^(?:[/\\]{2}([^/\\]+)(?=[/\\](?:[^/\\]|$)))?(.*)/);
+    const url = new URL("file:///");
+    url.pathname = encodeWhitespace(pathname.replace(/%/g, "%25"));
+    if (hostname !== undefined && hostname !== "localhost") {
+        url.hostname = hostname;
+        if (!url.hostname) {
+            throw new TypeError(`Invalid hostname: "${url.hostname}"`);
+        }
+    }
+    return url;
+}

package/esm/deps/jsr.io/@std/path/1.1.4/windows/to_namespaced_path.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolves path to a namespace path
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "@std/path/windows/to-namespaced-path";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const namespaced = toNamespacedPath("C:\\foo\\bar");
+ * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to resolve to namespaced path
+ * @returns The resolved namespaced path
+ */
+export declare function toNamespacedPath(path: string): string;
+//# sourceMappingURL=to_namespaced_path.d.ts.map

package/esm/deps/jsr.io/@std/path/1.1.4/windows/to_namespaced_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to_namespaced_path.d.ts","sourceRoot":"","sources":["../../../../../../../src/deps/jsr.io/@std/path/1.1.4/windows/to_namespaced_path.ts"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgCrD"}

package/esm/deps/jsr.io/@std/path/1.1.4/windows/to_namespaced_path.js

@@ -0,0 +1,49 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { CHAR_BACKWARD_SLASH, CHAR_COLON, CHAR_DOT, CHAR_QUESTION_MARK, } from "../_common/constants.js";
+import { isWindowsDeviceRoot } from "./_util.js";
+import { resolve } from "./resolve.js";
+/**
+ * Resolves path to a namespace path
+ *
+ * @example Usage
+ * ```ts
+ * import { toNamespacedPath } from "@std/path/windows/to-namespaced-path";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const namespaced = toNamespacedPath("C:\\foo\\bar");
+ * assertEquals(namespaced, "\\\\?\\C:\\foo\\bar");
+ * ```
+ *
+ * @param path The path to resolve to namespaced path
+ * @returns The resolved namespaced path
+ */
+export function toNamespacedPath(path) {
+    // Note: this will *probably* throw somewhere.
+    if (typeof path !== "string")
+        return path;
+    if (path.length === 0)
+        return "";
+    const resolvedPath = resolve(path);
+    if (resolvedPath.length >= 3) {
+        if (resolvedPath.charCodeAt(0) === CHAR_BACKWARD_SLASH) {
+            // Possible UNC root
+            if (resolvedPath.charCodeAt(1) === CHAR_BACKWARD_SLASH) {
+                const code = resolvedPath.charCodeAt(2);
+                if (code !== CHAR_QUESTION_MARK && code !== CHAR_DOT) {
+                    // Matched non-long UNC root, convert the path to a long UNC path
+                    return `\\\\?\\UNC\\${resolvedPath.slice(2)}`;
+                }
+            }
+        }
+        else if (isWindowsDeviceRoot(resolvedPath.charCodeAt(0))) {
+            // Possible device root
+            if (resolvedPath.charCodeAt(1) === CHAR_COLON &&
+                resolvedPath.charCodeAt(2) === CHAR_BACKWARD_SLASH) {
+                // Matched device root, convert the path to a long UNC path
+                return `\\\\?\\${resolvedPath}`;
+            }
+        }
+    }
+    return path;
+}

package/esm/deps/jsr.io/@std/text/1.0.16/closest_string.d.ts

@@ -0,0 +1,42 @@
+/** Options for {@linkcode closestString}. */
+export interface ClosestStringOptions {
+    /**
+     * Whether the distance should include case.
+     *
+     * @default {false}
+     */
+    caseSensitive?: boolean;
+    /**
+     * A custom comparison function to use for comparing strings.
+     *
+     * @param a The first string for comparison.
+     * @param b The second string for comparison.
+     * @returns The distance between the two strings.
+     * @default {levenshteinDistance}
+     */
+    compareFn?: (a: string, b: string) => number;
+}
+/**
+ * Finds the most similar string from an array of strings.
+ *
+ * By default, calculates the distance between words using the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}.
+ *
+ * @example Usage
+ * ```ts
+ * import { closestString } from "@std/text/closest-string";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const possibleWords = ["length", "size", "blah", "help"];
+ * const suggestion = closestString("hep", possibleWords);
+ *
+ * assertEquals(suggestion, "help");
+ * ```
+ *
+ * @param givenWord The string to measure distance against
+ * @param possibleWords The string-array to pick the closest string from
+ * @param options The options for the comparison.
+ * @returns The closest string
+ */
+export declare function closestString(givenWord: string, possibleWords: ReadonlyArray<string>, options?: ClosestStringOptions): string;
+//# sourceMappingURL=closest_string.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.16/closest_string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closest_string.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.16/closest_string.ts"],"names":[],"mappings":"AAIA,6CAA6C;AAC7C,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,EACpC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,MAAM,CAwBR"}

package/esm/deps/jsr.io/@std/text/1.0.16/closest_string.js

@@ -0,0 +1,46 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+import { levenshteinDistance } from "./levenshtein_distance.js";
+/**
+ * Finds the most similar string from an array of strings.
+ *
+ * By default, calculates the distance between words using the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}.
+ *
+ * @example Usage
+ * ```ts
+ * import { closestString } from "@std/text/closest-string";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const possibleWords = ["length", "size", "blah", "help"];
+ * const suggestion = closestString("hep", possibleWords);
+ *
+ * assertEquals(suggestion, "help");
+ * ```
+ *
+ * @param givenWord The string to measure distance against
+ * @param possibleWords The string-array to pick the closest string from
+ * @param options The options for the comparison.
+ * @returns The closest string
+ */
+export function closestString(givenWord, possibleWords, options) {
+    if (possibleWords.length === 0) {
+        throw new TypeError("When using closestString(), the possibleWords array must contain at least one word");
+    }
+    const { caseSensitive, compareFn = levenshteinDistance } = { ...options };
+    if (!caseSensitive) {
+        givenWord = givenWord.toLowerCase();
+    }
+    let nearestWord = possibleWords[0];
+    let closestStringDistance = Infinity;
+    for (const each of possibleWords) {
+        const distance = caseSensitive
+            ? compareFn(givenWord, each)
+            : compareFn(givenWord, each.toLowerCase());
+        if (distance < closestStringDistance) {
+            nearestWord = each;
+            closestStringDistance = distance;
+        }
+    }
+    return nearestWord;
+}

package/esm/deps/jsr.io/@std/text/1.0.16/levenshtein_distance.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Calculates the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}
+ * between two strings.
+ *
+ * > [!NOTE]
+ * > The complexity of this function is O(m * n), where m and n are the lengths
+ * > of the two strings. It's recommended to limit the length and validate input
+ * > if arbitrarily accepting input.
+ *
+ * @example Usage
+ * ```ts
+ * import { levenshteinDistance } from "@std/text/levenshtein-distance";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(levenshteinDistance("aa", "bb"), 2);
+ * ```
+ * @param str1 The first string.
+ * @param str2 The second string.
+ * @returns The Levenshtein distance between the two strings.
+ */
+export declare function levenshteinDistance(str1: string, str2: string): number;
+//# sourceMappingURL=levenshtein_distance.d.ts.map

package/esm/deps/jsr.io/@std/text/1.0.16/levenshtein_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"levenshtein_distance.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.16/levenshtein_distance.ts"],"names":[],"mappings":"AAmGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAWtE"}

package/esm/deps/jsr.io/@std/text/1.0.16/levenshtein_distance.js

@@ -0,0 +1,127 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+const { ceil } = Math;
+// This implements Myers' bit-vector algorithm as described here:
+// https://dl.acm.org/doi/pdf/10.1145/316542.316550
+const peq = new Uint32Array(0x110000);
+function myers32(t, p) {
+    const n = t.length;
+    const m = p.length;
+    for (let i = 0; i < m; i++) {
+        peq[p[i].codePointAt(0)] |= 1 << i;
+    }
+    const last = m - 1;
+    let pv = -1;
+    let mv = 0;
+    let score = m;
+    for (let j = 0; j < n; j++) {
+        const eq = peq[t[j].codePointAt(0)];
+        const xv = eq | mv;
+        const xh = (((eq & pv) + pv) ^ pv) | eq;
+        let ph = mv | ~(xh | pv);
+        let mh = pv & xh;
+        score += ((ph >>> last) & 1) - ((mh >>> last) & 1);
+        // Set the horizontal delta in the first row to +1
+        // because we are computing the distance between two full strings.
+        ph = (ph << 1) | 1;
+        mh = mh << 1;
+        pv = mh | ~(xv | ph);
+        mv = ph & xv;
+    }
+    for (let i = 0; i < m; i++) {
+        peq[p[i].codePointAt(0)] = 0;
+    }
+    return score;
+}
+function myersX(t, p) {
+    const n = t.length;
+    const m = p.length;
+    // Initialize the horizontal deltas to +1.
+    const h = new Int8Array(n).fill(1);
+    const bmax = ceil(m / 32) - 1;
+    // Process the blocks row by row so that we can use the fixed-size peq array.
+    for (let b = 0; b < bmax; b++) {
+        const start = b * 32;
+        const end = (b + 1) * 32;
+        for (let i = start; i < end; i++) {
+            peq[p[i].codePointAt(0)] |= 1 << i;
+        }
+        let pv = -1;
+        let mv = 0;
+        for (let j = 0; j < n; j++) {
+            const hin = h[j];
+            let eq = peq[t[j].codePointAt(0)];
+            const xv = eq | mv;
+            eq |= hin >>> 31;
+            const xh = (((eq & pv) + pv) ^ pv) | eq;
+            let ph = mv | ~(xh | pv);
+            let mh = pv & xh;
+            h[j] = (ph >>> 31) - (mh >>> 31);
+            ph = (ph << 1) | (-hin >>> 31);
+            mh = (mh << 1) | (hin >>> 31);
+            pv = mh | ~(xv | ph);
+            mv = ph & xv;
+        }
+        for (let i = start; i < end; i++) {
+            peq[p[i].codePointAt(0)] = 0;
+        }
+    }
+    const start = bmax * 32;
+    for (let i = start; i < m; i++) {
+        peq[p[i].codePointAt(0)] |= 1 << i;
+    }
+    const last = m - 1;
+    let pv = -1;
+    let mv = 0;
+    let score = m;
+    for (let j = 0; j < n; j++) {
+        const hin = h[j];
+        let eq = peq[t[j].codePointAt(0)];
+        const xv = eq | mv;
+        eq |= hin >>> 31;
+        const xh = (((eq & pv) + pv) ^ pv) | eq;
+        let ph = mv | ~(xh | pv);
+        let mh = pv & xh;
+        score += ((ph >>> last) & 1) - ((mh >>> last) & 1);
+        ph = (ph << 1) | (-hin >>> 31);
+        mh = (mh << 1) | (hin >>> 31);
+        pv = mh | ~(xv | ph);
+        mv = ph & xv;
+    }
+    for (let i = start; i < m; i++) {
+        peq[p[i].codePointAt(0)] = 0;
+    }
+    return score;
+}
+/**
+ * Calculates the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}
+ * between two strings.
+ *
+ * > [!NOTE]
+ * > The complexity of this function is O(m * n), where m and n are the lengths
+ * > of the two strings. It's recommended to limit the length and validate input
+ * > if arbitrarily accepting input.
+ *
+ * @example Usage
+ * ```ts
+ * import { levenshteinDistance } from "@std/text/levenshtein-distance";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(levenshteinDistance("aa", "bb"), 2);
+ * ```
+ * @param str1 The first string.
+ * @param str2 The second string.
+ * @returns The Levenshtein distance between the two strings.
+ */
+export function levenshteinDistance(str1, str2) {
+    let t = [...str1];
+    let p = [...str2];
+    if (t.length < p.length) {
+        [p, t] = [t, p];
+    }
+    if (p.length === 0) {
+        return t.length;
+    }
+    return p.length <= 32 ? myers32(t, p) : myersX(t, p);
+}

package/esm/src/config/init.js

@@ -2,7 +2,7 @@ import * as dntShim from "../../_dnt.shims.js";
 import { UI_CONFIGURATION } from "../ui/default.js";
 import { SeyunaSpinner } from "../helpers/cli.js";
 import { Brand } from "../helpers/styles.js";
-import { Input, Select } from "@jsr/cliffy__prompt";
+import { Input, Select } from "../../deps/jsr.io/@cliffy/prompt/1.0.0-rc.8/mod.js";
 /**
  * Initializes a new Seyuna project by creating a 'seyuna.json' configuration file.
  * This function performs safety checks to avoid overwriting existing configurations.
@@ -18,7 +18,7 @@ export async function initConfig() {
         default: "src/styles",
     }) || "src/styles";
     const mode = await Select.prompt({
-        message: `${Brand.muted("›")} Default color appearance mode`,
+        message: `${Brand.muted("›")} Default mode`,
         default: "system",
         options: [
             { name: "System", value: "system" },

package/esm/src/helpers/cli.js

@@ -1,4 +1,4 @@
-import { Spinner } from "@jsr/std__cli/unstable-spinner";
+import { Spinner } from "../../deps/jsr.io/@std/cli/1.0.25/unstable_spinner.js";
 import { Brand, seyunaGradient, Symbols } from "./styles.js";
 /**
  * A branded spinner class that provides visual feedback for long-running CLI operations.

package/esm/src/helpers/fs.js

@@ -1,6 +1,6 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { dirname, join } from "@jsr/std__path";
-import { ensureDir } from "@jsr/std__fs";
+import { dirname, join } from "../../deps/jsr.io/@std/path/1.1.4/mod.js";
+import { ensureDir } from "../../deps/jsr.io/@std/fs/1.0.21/mod.js";
 import { mergeConfig } from "../config/types.js";
 import { UI_CONFIGURATION } from "../ui/default.js";
 /**

package/esm/src/helpers/styles.js

@@ -1,4 +1,4 @@
-import * as colors from "@jsr/std__fmt/colors";
+import * as colors from "../../deps/jsr.io/@std/fmt/1.0.8/colors.js";
 /**
  * Standard brand colors and styles for the Seyuna CLI.
  * Provides a consistent visual identity across all command outputs.

package/esm/src/main.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { Deno as DenoShim } from "../_dnt.shims.js"; globalThis.Deno = DenoShim;
 /**
  * Seyuna CLI - Entrypoint
  *
@@ -11,8 +10,8 @@ import { Deno as DenoShim } from "../_dnt.shims.js"; globalThis.Deno = DenoShim;
  */
 import "../_dnt.polyfills.js";
 import * as dntShim from "../_dnt.shims.js";
-import { Command } from "@jsr/cliffy__command";
-import * as colors from "@jsr/std__fmt/colors";
+import { Command } from "../deps/jsr.io/@cliffy/command/1.0.0-rc.8/mod.js";
+import * as colors from "../deps/jsr.io/@std/fmt/1.0.8/colors.js";
 import { initConfig } from "./config/init.js";
 import { compile } from "./ui/compile.js";
 import { Brand, seyunaGradient } from "./helpers/styles.js";

package/esm/src/ui/compile.js

@@ -2,7 +2,7 @@ import * as dntShim from "../../_dnt.shims.js";
 import { GLOBAL_CSS } from "./global.css.js";
 import { createPathFromFileName, loadSeyunaUserConfig, saveFile, } from "../helpers/fs.js";
 import { SeyunaSpinner } from "../helpers/cli.js";
-import { delay } from "@jsr/std__async";
+import { delay } from "../../deps/jsr.io/@std/async/1.0.16/mod.js";
 import { Brand } from "../helpers/styles.js";
 /**
  * Main entrypoint for the UI compilation process.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seyuna/cli",
-  "version": "1.0.0-canary.23",
+  "version": "1.0.0-canary.25",
   "description": "Seyuna CLI",
   "repository": {
     "type": "git",
@@ -24,13 +24,6 @@
     "seyuna": "./esm/src/main.js"
   },
   "dependencies": {
-    "@jsr/cliffy__command": "^1.0.0-rc.8",
-    "@jsr/cliffy__prompt": "^1.0.0-rc.8",
-    "@jsr/std__async": "^1.0.0",
-    "@jsr/std__cli": "^1.0.25",
-    "@jsr/std__fmt": "^1.0.0",
-    "@jsr/std__fs": "^1.0.0",
-    "@jsr/std__path": "^1.0.0",
     "@deno/shim-deno": "~0.18.0"
   },
   "devDependencies": {