@miranda0808/maya-claude 0.1.0

package/vendor/shared-installer/src/cli-options.js

@@ -0,0 +1,53 @@
+"use strict";
+
+function parseCliArgs(argv = []) {
+  const options = {
+    command: null,
+    dryRun: false,
+    force: false,
+    target: undefined,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+
+    if (token === "--dry-run") {
+      options.dryRun = true;
+      continue;
+    }
+
+    if (token === "--force") {
+      options.force = true;
+      continue;
+    }
+
+    if (token === "--target") {
+      const target = argv[index + 1];
+
+      if (!target) {
+        throw new Error("Missing value for --target");
+      }
+
+      options.target = target;
+      index += 1;
+      continue;
+    }
+
+    if (token.startsWith("--")) {
+      throw new Error(`Unknown option: ${token}`);
+    }
+
+    if (!options.command) {
+      options.command = token;
+      continue;
+    }
+
+    throw new Error(`Unexpected argument: ${token}`);
+  }
+
+  return options;
+}
+
+module.exports = {
+  parseCliArgs,
+};

package/vendor/shared-installer/src/fs.js

@@ -0,0 +1,105 @@
+"use strict";
+
+const { access, copyFile, mkdir, readdir, readFile, stat, writeFile } = require("node:fs/promises");
+const path = require("node:path");
+
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+
+function fromPosixPath(basePath, relativePath) {
+  const segments = relativePath.split("/").filter(Boolean);
+  return path.join(basePath, ...segments);
+}
+
+function joinPosixPath(...segments) {
+  return segments.filter(Boolean).join("/").replace(/\/+/g, "/");
+}
+
+function resolveTargetDirectory(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const target = options.target || ".";
+
+  return path.resolve(cwd, target);
+}
+
+async function pathExists(targetPath) {
+  try {
+    await access(targetPath);
+    return true;
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      return false;
+    }
+
+    throw error;
+  }
+}
+
+async function assertExistingDirectory(targetPath) {
+  let details;
+
+  try {
+    details = await stat(targetPath);
+  } catch (error) {
+    if (error && error.code === "ENOENT") {
+      throw new Error(`Target directory does not exist: ${targetPath}`);
+    }
+
+    throw error;
+  }
+
+  if (!details.isDirectory()) {
+    throw new Error(`Target path is not a directory: ${targetPath}`);
+  }
+}
+
+async function ensureDirectory(targetPath) {
+  await mkdir(targetPath, { recursive: true });
+}
+
+async function listFilesRecursive(rootPath, currentRelative = "") {
+  const entries = await readdir(rootPath, { withFileTypes: true });
+  const files = [];
+
+  for (const entry of entries) {
+    const entryRelative = currentRelative ? joinPosixPath(currentRelative, entry.name) : entry.name;
+    const entryPath = path.join(rootPath, entry.name);
+
+    if (entry.isDirectory()) {
+      files.push(...(await listFilesRecursive(entryPath, entryRelative)));
+      continue;
+    }
+
+    files.push(entryRelative);
+  }
+
+  return files.sort();
+}
+
+function normalizeLineEndings(content) {
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+async function writeTextFile(targetPath, content) {
+  await writeFile(targetPath, normalizeLineEndings(content), "utf8");
+}
+
+async function copyOpaqueFile(sourcePath, destinationPath) {
+  await copyFile(sourcePath, destinationPath);
+}
+
+module.exports = {
+  assertExistingDirectory,
+  copyOpaqueFile,
+  ensureDirectory,
+  fromPosixPath,
+  joinPosixPath,
+  listFilesRecursive,
+  normalizeLineEndings,
+  pathExists,
+  readFile,
+  resolveTargetDirectory,
+  toPosixPath,
+  writeTextFile,
+};

package/vendor/shared-installer/src/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+const { parseCliArgs } = require("./cli-options");
+const { buildInstallPlan, installMaya } = require("./install");
+const { resolveTargetDirectory } = require("./fs");
+const { loadManifest } = require("./manifest");
+
+async function runInstallerCli(options = {}) {
+  const stdout = options.stdout || process.stdout;
+  const argv = options.argv || [];
+  const parsed = parseCliArgs(argv);
+
+  if (parsed.command !== "init") {
+    throw new Error("Expected the install command: init");
+  }
+
+  const summary = await installMaya({
+    cwd: options.cwd,
+    dryRun: parsed.dryRun,
+    force: parsed.force,
+    host: options.host,
+    installerRoot: options.installerRoot,
+    payloadRoot: options.payloadRoot,
+    repoRoot: options.repoRoot,
+    target: parsed.target,
+  });
+
+  if (summary.dryRun) {
+    stdout.write(`Planned ${summary.operations.length} Maya files for ${summary.host}.\n`);
+  } else {
+    stdout.write(`Installed Maya for ${summary.host} into ${summary.targetDirectory}.\n`);
+  }
+
+  return summary;
+}
+
+module.exports = {
+  buildInstallPlan,
+  installMaya,
+  loadManifest,
+  parseCliArgs,
+  resolveTargetDirectory,
+  runInstallerCli,
+};

package/vendor/shared-installer/src/install.js

@@ -0,0 +1,157 @@
+"use strict";
+
+const path = require("node:path");
+const { renderBootstrap } = require("./bootstrap");
+const {
+  assertExistingDirectory,
+  copyOpaqueFile,
+  ensureDirectory,
+  fromPosixPath,
+  joinPosixPath,
+  listFilesRecursive,
+  pathExists,
+  resolveTargetDirectory,
+  toPosixPath,
+  writeTextFile,
+} = require("./fs");
+const { loadManifest, resolveInstallerRoot, resolvePayloadRoot } = require("./manifest");
+
+async function expandManifestFiles(files, context) {
+  const operations = [];
+
+  for (const entry of files) {
+    const sourceBase = entry.template ? context.installerRoot : context.payloadRoot;
+    const sourceRoot = fromPosixPath(sourceBase, entry.source);
+    const sourceDetails = await require("node:fs/promises").stat(sourceRoot);
+
+    if (sourceDetails.isDirectory()) {
+      const children = await listFilesRecursive(sourceRoot);
+
+      for (const child of children) {
+        const destinationRelative = joinPosixPath(entry.destination, child);
+        operations.push({
+          destinationPath: fromPosixPath(context.targetDirectory, destinationRelative),
+          destinationRelative,
+          sourcePath: path.join(sourceRoot, ...child.split("/")),
+          sourceRelative: joinPosixPath(entry.source, child),
+          template: false,
+        });
+      }
+
+      continue;
+    }
+
+    operations.push({
+      destinationPath: fromPosixPath(context.targetDirectory, entry.destination),
+      destinationRelative: entry.destination,
+      sourcePath: sourceRoot,
+      sourceRelative: entry.source,
+      template: entry.template,
+    });
+  }
+
+  return operations;
+}
+
+async function buildInstallPlan(options = {}) {
+  if (!options.host) {
+    throw new Error("A host id is required.");
+  }
+
+  const installerRoot = resolveInstallerRoot(options);
+  const payloadRoot = resolvePayloadRoot(options);
+  const targetDirectory = resolveTargetDirectory({ cwd: options.cwd, target: options.target });
+  await assertExistingDirectory(targetDirectory);
+
+  const commonManifest = await loadManifest("common", { installerRoot });
+  const hostManifest = await loadManifest(options.host, { installerRoot });
+  const operations = [
+    ...(await expandManifestFiles(commonManifest.files, { installerRoot, payloadRoot, targetDirectory })),
+    ...(await expandManifestFiles(hostManifest.files, { installerRoot, payloadRoot, targetDirectory })),
+  ];
+
+  const plannedOperations = [];
+
+  for (const operation of operations) {
+    plannedOperations.push({
+      ...operation,
+      exists: await pathExists(operation.destinationPath),
+    });
+  }
+
+  const conflicts = plannedOperations
+    .filter((operation) => operation.exists)
+    .map((operation) => operation.destinationRelative);
+
+  return {
+    conflicts,
+    dryRun: Boolean(options.dryRun),
+    force: Boolean(options.force),
+    host: options.host,
+    installerRoot,
+    manifests: {
+      common: commonManifest.manifestPath,
+      host: hostManifest.manifestPath,
+    },
+    operations: plannedOperations,
+    payloadRoot,
+    targetDirectory,
+  };
+}
+
+function summarizePlan(plan) {
+  return {
+    conflicts: [...plan.conflicts],
+    dryRun: plan.dryRun,
+    force: plan.force,
+    host: plan.host,
+    manifests: { ...plan.manifests },
+    operations: plan.operations.map((operation) => ({
+      destinationRelative: operation.destinationRelative,
+      exists: operation.exists,
+      mode: operation.template ? "template" : "copy",
+      sourceRelative: operation.sourceRelative,
+    })),
+    targetDirectory: plan.targetDirectory,
+  };
+}
+
+async function installMaya(options = {}) {
+  const plan = await buildInstallPlan(options);
+
+  if (plan.conflicts.length > 0 && !plan.force && !plan.dryRun) {
+    throw new Error(
+      `Refusing to overwrite files that already exists without --force: ${plan.conflicts.join(", ")}`,
+    );
+  }
+
+  if (plan.dryRun) {
+    return summarizePlan(plan);
+  }
+
+  const writtenFiles = [];
+
+  for (const operation of plan.operations) {
+    await ensureDirectory(path.dirname(operation.destinationPath));
+
+    if (operation.template) {
+      const content = await renderBootstrap(operation, { host: plan.host });
+      await writeTextFile(operation.destinationPath, content);
+    } else {
+      await copyOpaqueFile(operation.sourcePath, operation.destinationPath);
+    }
+
+    writtenFiles.push(operation.destinationRelative);
+  }
+
+  return {
+    ...summarizePlan(plan),
+    writtenFiles,
+  };
+}
+
+module.exports = {
+  buildInstallPlan,
+  installMaya,
+  summarizePlan,
+};

package/vendor/shared-installer/src/manifest.js

@@ -0,0 +1,52 @@
+"use strict";
+
+const path = require("node:path");
+const { readFile } = require("./fs");
+
+function resolveInstallerRoot(options = {}) {
+  return options.installerRoot || path.resolve(__dirname, "..");
+}
+
+function resolvePayloadRoot(options = {}) {
+  return options.payloadRoot || options.repoRoot || path.resolve(__dirname, "..", "..", "..");
+}
+
+function getManifestPath(name, options = {}) {
+  return path.join(resolveInstallerRoot(options), "manifests", `${name}-files.json`);
+}
+
+function normalizeEntry(entry) {
+  if (typeof entry === "string") {
+    return {
+      source: entry,
+      destination: entry,
+      template: false,
+    };
+  }
+
+  return {
+    source: entry.source,
+    destination: entry.destination || entry.source,
+    template: Boolean(entry.template),
+  };
+}
+
+async function loadManifest(name, options = {}) {
+  const manifestPath = getManifestPath(name, options);
+  const content = await readFile(manifestPath, "utf8");
+  const manifest = JSON.parse(content);
+
+  return {
+    name,
+    manifestPath,
+    files: manifest.files.map(normalizeEntry),
+  };
+}
+
+module.exports = {
+  getManifestPath,
+  loadManifest,
+  normalizeEntry,
+  resolveInstallerRoot,
+  resolvePayloadRoot,
+};

package/vendor/shared-installer/templates/claude/.claude/skills/.gitkeep

@@ -0,0 +1 @@
+

package/vendor/shared-installer/templates/claude/CLAUDE.md

@@ -0,0 +1,27 @@
+# Maya
+
+Maya is the repo-local marketing department for this repository.
+
+## Runtime Rules
+
+- Address the user as `Justin`.
+- Only open Maya when Justin explicitly asks for Maya or starts a marketing workflow.
+- Use only `/maya:consult` and `/maya:task` as Maya entrypoints.
+- Keep Maya repo-local in this project.
+- In task mode, show the proposed specialist chain for approval before any specialists execute.
+
+## Runtime Files
+
+Use these repo-local Maya files and folders:
+- `MAYA.md`
+- `MAYA-CATALOG.md`
+- `MAYA-DEPENDENCIES.md`
+- `commands/`
+- `.maya/`
+- `.claude/skills/`
+
+## Mode Rules
+
+- `/maya:consult` is advisory and lower-cost.
+- `/maya:task` is approval-gated execution.
+- Maya never silently switches modes.

package/vendor/shared-installer/templates/codex/.agent/skills/.gitkeep

@@ -0,0 +1 @@
+

package/vendor/shared-installer/templates/codex/AGENTS.md

@@ -0,0 +1,27 @@
+# Maya
+
+Maya is the repo-local marketing department for this repository.
+
+## Runtime Rules
+
+- Address the user as `Justin`.
+- Only open Maya when Justin explicitly asks for Maya or starts a marketing workflow.
+- Use only `/maya:consult` and `/maya:task` as Maya entrypoints.
+- Keep Maya repo-local in this project.
+- In task mode, show the proposed specialist chain for approval before any specialists execute.
+
+## Runtime Files
+
+Use these repo-local Maya files and folders:
+- `MAYA.md`
+- `MAYA-CATALOG.md`
+- `MAYA-DEPENDENCIES.md`
+- `commands/`
+- `.maya/`
+- `.agent/skills/`
+
+## Mode Rules
+
+- `/maya:consult` is advisory and lower-cost.
+- `/maya:task` is approval-gated execution.
+- Maya never silently switches modes.