site-index 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Deasilsoft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,107 @@
+# site-index
+
+CLI for creating site-index modules and generating/checking sitemap and robots.txt artifacts.
+
+[Repository README](../../README.md)
+
+## Install
+
+```bash
+npm install -D site-index
+```
+
+Requirements:
+
+- Node.js `>=22`
+
+## When to use
+
+Use `site-index` when you want command-line workflows for:
+
+- scaffolding `*.site-index.*` modules
+- generating sitemap and robots.txt artifacts
+- validating site-index modules in CI
+
+## When not to use
+
+- Use [`@site-index/vite-plugin`](../@site-index/vite-plugin/README.md) for Vite-native integration.
+- Use [`@site-index/core`](../@site-index/core/README.md) for custom programmatic pipelines.
+
+## Global options
+
+- `--quiet`: suppress informational output
+- `--verbose`: enable verbose logging
+
+## Commands
+
+### `make`
+
+```bash
+site-index make <filePath> [--format <format>] [--force]
+```
+
+Behavior:
+
+- creates a new site-index module template
+- supports `--format ts`
+- supports `--format esm`
+- defaults format to `ts`
+- refuses to overwrite existing files unless `--force` is used
+- normalizes output filenames to:
+  - `<name>.site-index.ts`
+  - `<name>.site-index.mjs`
+
+### `build`
+
+```bash
+site-index build --site-url <url> [--root <path>] [--out <dir>] [--config <path>]
+```
+
+Behavior:
+
+- generates site-index artifacts
+- writes artifacts to `--out` (default: `dist`)
+- requires `--site-url`
+- validates `--site-url` as a valid URL
+- validates `--out` resolves within `--root`
+- uses Vite config when `--config` is provided
+- `--root` defaults to current working directory
+- `--config` must resolve within `--root`
+
+### `check`
+
+```bash
+site-index check --site-url <url> [--root <path>] [--config <path>]
+```
+
+Behavior:
+
+- validates discovered site-index modules for CI
+- requires `--site-url`
+- fails when warnings are produced
+- uses Vite config when `--config` is provided
+- `--root` defaults to current working directory
+- `--config` must resolve within `--root`
+
+## Examples
+
+```bash
+npx site-index make src/pages.site-index.ts --format ts
+npx site-index make src/pages.site-index.mjs --format esm
+npx site-index build --site-url https://example.com
+npx site-index check --site-url https://example.com
+```
+
+Local monorepo development:
+
+```bash
+npm run cli -- build --site-url https://example.com
+```
+
+## How it fits in the monorepo
+
+`site-index` is the user-facing CLI package built on:
+
+- [`@site-index/vite-runtime`](../@site-index/vite-runtime/README.md)
+- [`@site-index/core`](../@site-index/core/README.md)
+- [`@site-index/observability`](../@site-index/observability/README.md)

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from "./main.js";
+await main();

package/dist/domains/make/adapters/handlebars.d.ts

@@ -0,0 +1,3 @@
+type TemplateContext = Record<string, string>;
+export declare function renderTemplate(template: string, context: TemplateContext): string;
+export {};

package/dist/domains/make/adapters/handlebars.js

@@ -0,0 +1,6 @@
+const TOKEN_PATTERN = /\{\{\s*([a-zA-Z0-9_]+)\s*}}/g;
+export function renderTemplate(template, context) {
+    return template.replaceAll(TOKEN_PATTERN, (token, variableName) => {
+        return context[variableName] ?? token;
+    });
+}

package/dist/domains/make/adapters/site-index.d.ts

@@ -0,0 +1,8 @@
+import type { Format } from "../types.js";
+type TemplateData = {
+    filePath: string;
+    format: Format;
+    lastModified: string;
+};
+export declare function makeSiteIndexModule(data: TemplateData): Promise<void>;
+export {};

package/dist/domains/make/adapters/site-index.js

@@ -0,0 +1,18 @@
+import NodeFS from "node:fs/promises";
+import NodePath from "node:path";
+import { fileURLToPath } from "node:url";
+import { renderTemplate } from "./handlebars.js";
+const DIR = NodePath.dirname(fileURLToPath(import.meta.url));
+const TEMPLATES = {
+    esm: NodePath.resolve(DIR, "../templates/site-index.esm.hbs"),
+    ts: NodePath.resolve(DIR, "../templates/site-index.ts.hbs"),
+};
+export async function makeSiteIndexModule(data) {
+    const templatePath = TEMPLATES[data.format];
+    const template = await NodeFS.readFile(templatePath, "utf8");
+    const content = renderTemplate(template, {
+        lastModified: data.lastModified,
+    });
+    await NodeFS.mkdir(NodePath.dirname(data.filePath), { recursive: true });
+    await NodeFS.writeFile(data.filePath, content, "utf8");
+}

package/dist/domains/make/commands/make.command.d.ts

@@ -0,0 +1,2 @@
+import type { CAC } from "cac";
+export declare function initMakeCommand(cli: CAC): void;

package/dist/domains/make/commands/make.command.js

@@ -0,0 +1,15 @@
+import { runMake } from "../make.service.js";
+import { MakeConfigSchema } from "../schemas/make.schema.js";
+export function initMakeCommand(cli) {
+    cli
+        .command("make <filePath>", "Create a new site-index module")
+        .option("--format <format>", "Module format (ts | esm)")
+        .option("--force", "Overwrite if the file already exists")
+        .action(async (filePath, options) => {
+        await runMake(MakeConfigSchema.parse({
+            filePath,
+            format: options.format,
+            force: options.force,
+        }));
+    });
+}

package/dist/domains/make/make.service.d.ts

@@ -0,0 +1,2 @@
+import type { MakeConfig } from "./types.js";
+export declare function runMake(config: MakeConfig): Promise<void>;

package/dist/domains/make/make.service.js

@@ -0,0 +1,14 @@
+import { logger } from "../../shared/logging/logger.js";
+import { fileExists } from "../../shared/utils/fs.js";
+import { makeSiteIndexModule } from "./adapters/site-index.js";
+export async function runMake(config) {
+    if ((await fileExists(config.outputFilePath)) && !config.force) {
+        throw new Error(`Refusing to overwrite existing file: ${config.outputFilePath} (use --force)`);
+    }
+    await makeSiteIndexModule({
+        filePath: config.outputFilePath,
+        format: config.format,
+        lastModified: new Date().toISOString(),
+    });
+    logger.info(`Created file: ${config.outputFilePath}`);
+}

package/dist/domains/make/schemas/make.schema.d.ts

@@ -0,0 +1,14 @@
+import { z as Zod } from "zod";
+import { type MakeConfig } from "../types.js";
+export declare const MakeConfigSchema: Zod.ZodPipe<Zod.ZodObject<{
+    filePath: Zod.ZodString;
+    format: Zod.ZodDefault<Zod.ZodEnum<{
+        ts: "ts";
+        esm: "esm";
+    }>>;
+    force: Zod.ZodDefault<Zod.ZodBoolean>;
+}, Zod.core.$strip>, Zod.ZodTransform<MakeConfig, {
+    filePath: string;
+    format: "ts" | "esm";
+    force: boolean;
+}>>;

package/dist/domains/make/schemas/make.schema.js

@@ -0,0 +1,43 @@
+import NodePath from "node:path";
+import { z as Zod } from "zod";
+import { isRelativePathEscapingRoot } from "../../../shared/utils/path.js";
+import { FORMATS } from "../types.js";
+const EXTENSIONS = {
+    ts: "ts",
+    esm: "mjs",
+};
+const EXT_PATTERN = Object.values(EXTENSIONS).join("|");
+function isWithinCurrentWorkingDirectory(filePath) {
+    const cwd = process.cwd();
+    const resolved = NodePath.resolve(filePath);
+    const relative = NodePath.relative(cwd, resolved);
+    return relative !== "" && !isRelativePathEscapingRoot(relative);
+}
+function normalizeBaseName(filePath) {
+    const name = NodePath.basename(filePath);
+    return name
+        .replace(new RegExp(String.raw `\.site-index\.(${EXT_PATTERN})$`), "")
+        .replace(new RegExp(String.raw `\.(${EXT_PATTERN})$`), "");
+}
+const MakeOptionsSchema = Zod.object({
+    filePath: Zod.string()
+        .trim()
+        .min(1, { error: "File path is required" })
+        .refine(isWithinCurrentWorkingDirectory, {
+        error: "File path must stay within the current working directory",
+    }),
+    format: Zod.enum(FORMATS, {
+        error: "Invalid option: --format must be one of: ts, esm",
+    }).default("ts"),
+    force: Zod.boolean().default(false),
+});
+export const MakeConfigSchema = MakeOptionsSchema.transform((options) => {
+    const resolved = NodePath.resolve(options.filePath);
+    const dir = NodePath.dirname(resolved);
+    const base = normalizeBaseName(resolved);
+    const ext = EXTENSIONS[options.format];
+    return {
+        ...options,
+        outputFilePath: NodePath.resolve(dir, `${base}.site-index.${ext}`),
+    };
+});

package/dist/domains/make/templates/site-index.esm.hbs

@@ -0,0 +1,9 @@
+/** @type {import("@site-index/core").SiteIndex[]} */
+const siteIndexes = [
+  {
+    url: "/",
+    lastModified: "{{lastModified}}",
+  },
+];
+
+export default { siteIndexes };

package/dist/domains/make/templates/site-index.ts.hbs

@@ -0,0 +1,10 @@
+import type { SiteIndex } from "@site-index/core";
+
+const siteIndexes = [
+  {
+    url: "/",
+    lastModified: "{{lastModified}}",
+  },
+] satisfies SiteIndex[];
+
+export default { siteIndexes };

package/dist/domains/make/types.d.ts

@@ -0,0 +1,8 @@
+export declare const FORMATS: readonly ["ts", "esm"];
+export type Format = (typeof FORMATS)[number];
+export type MakeConfig = {
+    filePath: string;
+    format: Format;
+    force: boolean;
+    outputFilePath: string;
+};

package/dist/domains/make/types.js

@@ -0,0 +1 @@
+export const FORMATS = ["ts", "esm"];

package/dist/domains/site-indexes/build.service.d.ts

@@ -0,0 +1,2 @@
+import type { BuildConfig } from "./types.js";
+export declare function runBuild(config: BuildConfig): Promise<void>;

package/dist/domains/site-indexes/build.service.js

@@ -0,0 +1,35 @@
+import { createRuntimeService } from "@site-index/vite-runtime";
+import NodeFS from "node:fs/promises";
+import NodePath from "node:path";
+import { logger } from "../../shared/logging/logger.js";
+import { isRelativePathEscapingRoot } from "../../shared/utils/path.js";
+import { makeResolvedViteConfig } from "./vite.config.js";
+async function writeArtifacts(outPath, artifacts) {
+    const resolvedOutPath = NodePath.resolve(outPath);
+    for (const artifact of artifacts) {
+        const filePath = NodePath.resolve(resolvedOutPath, artifact.filePath);
+        const relativePath = NodePath.relative(resolvedOutPath, filePath);
+        if (isRelativePathEscapingRoot(relativePath)) {
+            throw new Error(`Artifact path escapes output directory: ${artifact.filePath}`);
+        }
+        await NodeFS.mkdir(NodePath.dirname(filePath), { recursive: true });
+        await NodeFS.writeFile(filePath, artifact.content, "utf8");
+    }
+}
+export async function runBuild(config) {
+    const runtime = createRuntimeService()
+        .withOptions({
+        siteUrl: config.siteUrl,
+        extensions: undefined,
+    })
+        .withViteConfig(makeResolvedViteConfig(config))
+        .build();
+    try {
+        const result = await runtime.buildArtifacts();
+        logger.warn(result.warnings);
+        await writeArtifacts(config.outPath, result.data);
+    }
+    finally {
+        await runtime.close();
+    }
+}

package/dist/domains/site-indexes/check.service.d.ts

@@ -0,0 +1,2 @@
+import type { CheckConfig } from "./types.js";
+export declare function runCheck(config: CheckConfig): Promise<void>;

package/dist/domains/site-indexes/check.service.js

@@ -0,0 +1,22 @@
+import { createRuntimeService } from "@site-index/vite-runtime";
+import { logger } from "../../shared/logging/logger.js";
+import { makeResolvedViteConfig } from "./vite.config.js";
+export async function runCheck(config) {
+    const runtime = createRuntimeService()
+        .withOptions({
+        siteUrl: config.siteUrl,
+        extensions: undefined,
+    })
+        .withViteConfig(makeResolvedViteConfig(config))
+        .build();
+    try {
+        const result = await runtime.buildArtifacts();
+        if (result.warnings.length > 0) {
+            logger.warn(result.warnings);
+            throw new Error(`Check failed with ${result.warnings.length} warning(s)`);
+        }
+    }
+    finally {
+        await runtime.close();
+    }
+}

package/dist/domains/site-indexes/commands/build.command.d.ts

@@ -0,0 +1,2 @@
+import type { CAC } from "cac";
+export declare function initBuildCommand(cli: CAC): void;

package/dist/domains/site-indexes/commands/build.command.js

@@ -0,0 +1,13 @@
+import { runBuild } from "../build.service.js";
+import { BuildConfigSchema } from "../schemas/build.schema.js";
+export function initBuildCommand(cli) {
+    cli
+        .command("build", "Generate site-index artifacts")
+        .option("--site-url <url>", "Site URL used for absolute sitemap links")
+        .option("--root <path>", "Project root")
+        .option("--out <dir>", "Output directory (relative to root)")
+        .option("--config <path>", "Path to Vite config")
+        .action(async (options) => {
+        await runBuild(BuildConfigSchema.parse(options));
+    });
+}

package/dist/domains/site-indexes/commands/check.command.d.ts

@@ -0,0 +1,2 @@
+import type { CAC } from "cac";
+export declare function initCheckCommand(cli: CAC): void;

package/dist/domains/site-indexes/commands/check.command.js

@@ -0,0 +1,12 @@
+import { runCheck } from "../check.service.js";
+import { CheckConfigSchema } from "../schemas/check.schema.js";
+export function initCheckCommand(cli) {
+    cli
+        .command("check", "Validate site-index modules for CI")
+        .option("--site-url <url>", "Site URL used for absolute sitemap links")
+        .option("--config <path>", "Path to Vite config")
+        .option("--root <path>", "Project root")
+        .action(async (options) => {
+        await runCheck(CheckConfigSchema.parse(options));
+    });
+}

package/dist/domains/site-indexes/schemas/build.schema.d.ts

@@ -0,0 +1,13 @@
+import { z as Zod } from "zod";
+import { type BuildConfig } from "../types.js";
+export declare const BuildConfigSchema: Zod.ZodPipe<Zod.ZodObject<{
+    siteUrl: Zod.ZodPipe<Zod.ZodString, Zod.ZodURL>;
+    root: Zod.ZodOptional<Zod.ZodString>;
+    config: Zod.ZodOptional<Zod.ZodString>;
+    out: Zod.ZodDefault<Zod.ZodString>;
+}, Zod.core.$strip>, Zod.ZodTransform<BuildConfig, {
+    siteUrl: string;
+    out: string;
+    root?: string | undefined;
+    config?: string | undefined;
+}>>;

package/dist/domains/site-indexes/schemas/build.schema.js

@@ -0,0 +1,23 @@
+import NodePath from "node:path";
+import { z as Zod } from "zod";
+import {} from "../types.js";
+import { BaseOptionsSchema, isPathWithinRoot, resolveBaseConfig, } from "./shared.schema.js";
+const BuildOptionsSchema = BaseOptionsSchema.extend({
+    out: Zod.string().trim().min(1).default("dist"),
+}).superRefine((options, context) => {
+    const rootPath = NodePath.resolve(options.root ?? process.cwd());
+    if (!isPathWithinRoot(rootPath, options.out)) {
+        context.addIssue({
+            code: "custom",
+            path: ["out"],
+            message: "Invalid option: --out must resolve within --root",
+        });
+    }
+});
+export const BuildConfigSchema = BuildOptionsSchema.transform(({ out, ...options }) => {
+    const baseConfig = resolveBaseConfig(options);
+    return {
+        ...baseConfig,
+        outPath: NodePath.resolve(baseConfig.rootPath, out),
+    };
+});

package/dist/domains/site-indexes/schemas/check.schema.d.ts

@@ -0,0 +1,9 @@
+export declare const CheckConfigSchema: import("zod").ZodPipe<import("zod").ZodObject<{
+    siteUrl: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodURL>;
+    root: import("zod").ZodOptional<import("zod").ZodString>;
+    config: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, import("zod").ZodTransform<import("../types.js").BaseConfig, {
+    siteUrl: string;
+    root?: string | undefined;
+    config?: string | undefined;
+}>>;

package/dist/domains/site-indexes/schemas/check.schema.js

@@ -0,0 +1,2 @@
+import { BaseOptionsSchema, resolveBaseConfig } from "./shared.schema.js";
+export const CheckConfigSchema = BaseOptionsSchema.transform((options) => resolveBaseConfig(options));

package/dist/domains/site-indexes/schemas/shared.schema.d.ts

@@ -0,0 +1,11 @@
+import { z as Zod } from "zod";
+import type { BaseConfig } from "../types.js";
+export declare function isPathWithinRoot(rootPath: string, filePath: string): boolean;
+export declare const BaseOptionsSchema: Zod.ZodObject<{
+    siteUrl: Zod.ZodPipe<Zod.ZodString, Zod.ZodURL>;
+    root: Zod.ZodOptional<Zod.ZodString>;
+    config: Zod.ZodOptional<Zod.ZodString>;
+}, Zod.core.$strip>;
+type BaseOptions = Zod.output<typeof BaseOptionsSchema>;
+export declare function resolveBaseConfig(options: BaseOptions): BaseConfig;
+export {};

package/dist/domains/site-indexes/schemas/shared.schema.js

@@ -0,0 +1,45 @@
+import NodePath from "node:path";
+import { z as Zod } from "zod";
+import { isRelativePathEscapingRoot } from "../../../shared/utils/path.js";
+export function isPathWithinRoot(rootPath, filePath) {
+    const resolvedRoot = NodePath.resolve(rootPath);
+    const resolvedPath = NodePath.resolve(resolvedRoot, filePath);
+    const relativePath = NodePath.relative(resolvedRoot, resolvedPath);
+    return !isRelativePathEscapingRoot(relativePath);
+}
+export const BaseOptionsSchema = Zod.object({
+    siteUrl: Zod.string({ error: "Missing required option: --site-url <url>" })
+        .trim()
+        .min(1, { error: "Missing required option: --site-url <url>" })
+        .pipe(Zod.url({
+        error: "Invalid option: --site-url must be a valid URL",
+    })),
+    root: Zod.string().trim().min(1).optional(),
+    config: Zod.string().trim().min(1).optional(),
+}).superRefine((options, context) => {
+    if (!options.config) {
+        return;
+    }
+    const rootPath = NodePath.resolve(options.root ?? process.cwd());
+    if (!isPathWithinRoot(rootPath, options.config)) {
+        context.addIssue({
+            code: "custom",
+            path: ["config"],
+            message: "Invalid option: --config must resolve within --root",
+        });
+    }
+});
+export function resolveBaseConfig(options) {
+    const rootPath = NodePath.resolve(options.root ?? process.cwd());
+    if (options.config) {
+        return {
+            siteUrl: options.siteUrl,
+            rootPath,
+            configFile: NodePath.resolve(rootPath, options.config),
+        };
+    }
+    return {
+        siteUrl: options.siteUrl,
+        rootPath,
+    };
+}

package/dist/domains/site-indexes/types.d.ts

@@ -0,0 +1,9 @@
+export type BaseConfig = {
+    siteUrl: string;
+    rootPath: string;
+    configFile?: string;
+};
+export type BuildConfig = BaseConfig & {
+    outPath: string;
+};
+export type CheckConfig = BaseConfig;

package/dist/domains/site-indexes/types.js

@@ -0,0 +1 @@
+export {};

package/dist/domains/site-indexes/vite.config.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeViteConfig } from "@site-index/vite-runtime";
+import type { BaseConfig } from "./types.js";
+export declare function makeResolvedViteConfig(config: BaseConfig): RuntimeViteConfig;

package/dist/domains/site-indexes/vite.config.js

@@ -0,0 +1,7 @@
+export function makeResolvedViteConfig(config) {
+    return {
+        root: config.rootPath,
+        mode: "production",
+        ...(config.configFile ? { configFile: config.configFile } : {}),
+    };
+}

package/dist/main.d.ts

@@ -0,0 +1 @@
+export declare function main(argv?: string[]): Promise<void>;

package/dist/main.js

@@ -0,0 +1,38 @@
+import { cac } from "cac";
+import pkg from "../package.json" with { type: "json" };
+import { initMakeCommand } from "./domains/make/commands/make.command.js";
+import { initBuildCommand } from "./domains/site-indexes/commands/build.command.js";
+import { initCheckCommand } from "./domains/site-indexes/commands/check.command.js";
+import { logger } from "./shared/logging/logger.js";
+function hasCommandToken(argv) {
+    return argv.slice(2).some((argument) => !argument.startsWith("-"));
+}
+export async function main(argv = process.argv) {
+    try {
+        const cli = cac("site-index");
+        cli.option("--quiet", "Suppress informational output");
+        cli.option("--verbose", "Enable verbose logging");
+        initBuildCommand(cli);
+        initCheckCommand(cli);
+        initMakeCommand(cli);
+        cli.help();
+        cli.version(pkg.version);
+        const parsed = cli.parse(argv, { run: false });
+        logger.configure({
+            quiet: Boolean(parsed.options.quiet),
+            verbose: Boolean(parsed.options.verbose),
+        });
+        if (parsed.options.help || parsed.options.version) {
+            return;
+        }
+        if (!hasCommandToken(argv)) {
+            cli.outputHelp();
+            return;
+        }
+        await cli.runMatchedCommand();
+    }
+    catch (error) {
+        logger.error(error);
+        process.exitCode = 1;
+    }
+}

package/dist/shared/logging/logger.d.ts

@@ -0,0 +1,2 @@
+import { Logger } from "@site-index/observability";
+export declare const logger: Logger;

package/dist/shared/logging/logger.js

@@ -0,0 +1,2 @@
+import { Logger } from "@site-index/observability";
+export const logger = new Logger();

package/dist/shared/utils/fs.d.ts

@@ -0,0 +1 @@
+export declare function fileExists(filePath: string): Promise<boolean>;

package/dist/shared/utils/fs.js

@@ -0,0 +1,16 @@
+import NodeFS from "node:fs/promises";
+export async function fileExists(filePath) {
+    try {
+        await NodeFS.access(filePath);
+        return true;
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/shared/utils/path.d.ts

@@ -0,0 +1 @@
+export declare function isRelativePathEscapingRoot(relativePath: string): boolean;

package/dist/shared/utils/path.js

@@ -0,0 +1,6 @@
+import NodePath from "node:path";
+export function isRelativePathEscapingRoot(relativePath) {
+    return (relativePath === ".." ||
+        relativePath.startsWith(`..${NodePath.sep}`) ||
+        NodePath.isAbsolute(relativePath));
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "site-index",
+  "version": "0.1.0",
+  "description": "CLI for generating sitemap and robots.txt artifacts from site-index modules.",
+  "keywords": [
+    "site-index",
+    "sitemap",
+    "robots",
+    "seo",
+    "vite",
+    "cli"
+  ],
+  "homepage": "https://github.com/Deasilsoft/site-index/tree/main/packages/site-index",
+  "bugs": {
+    "url": "https://github.com/Deasilsoft/site-index/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Deasilsoft/site-index.git",
+    "directory": "packages/site-index"
+  },
+  "license": "MIT",
+  "author": "Deasilsoft <contact@deasilsoft.com>",
+  "type": "module",
+  "bin": {
+    "site-index": "dist/bin.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.tsbuildinfo"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "postbuild": "npm run build:executable && npm run build:templates",
+    "build:executable": "chmod +x ./dist/bin.js",
+    "build:templates": "mkdir -p dist/domains/make/templates && cp -R src/domains/make/templates/. dist/domains/make/templates/",
+    "clean": "rm -rf dist coverage",
+    "precli": "npm run clean && npm run build",
+    "cli": "node ./dist/bin.js",
+    "prepack": "npm run clean && npm run build",
+    "pretest": "npm pack --dry-run",
+    "test": "vitest run --coverage",
+    "pretypecheck": "npm run build",
+    "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.test.json"
+  },
+  "dependencies": {
+    "@site-index/core": "0.1.0",
+    "@site-index/observability": "0.1.0",
+    "@site-index/vite-runtime": "0.1.0",
+    "cac": "^7.0.0",
+    "vite": "^8.0.12",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.1.6",
+    "vitest": "^4.1.6"
+  },
+  "engines": {
+    "node": ">=22"
+  }
+}