@ulpi/cli 0.1.5 → 0.1.7

package/dist/chunk-IFATANHR.js

@@ -1,453 +0,0 @@
-import {
-  USER_SKILLS_DIR,
-  USER_TEMPLATES_DIR
-} from "./chunk-DDRLI6JU.js";
-
-// ../../packages/templates-engine/dist/index.js
-import * as fs from "fs";
-import * as path from "path";
-import { parse as parseYaml } from "yaml";
-import * as fs2 from "fs";
-import * as path2 from "path";
-import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
-import * as fs3 from "fs";
-import * as path3 from "path";
-function findTemplatesDir() {
-  let dir = path.dirname(new URL(import.meta.url).pathname);
-  for (let i = 0; i < 5; i++) {
-    const candidate = path.join(dir, "templates");
-    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
-      return candidate;
-    }
-    dir = path.dirname(dir);
-  }
-  return path.resolve(dir, "templates");
-}
-var MAX_TEMPLATE_SIZE = 1e6;
-function loadTemplateFile(filePath) {
-  try {
-    const stat = fs.statSync(filePath);
-    if (stat.size > MAX_TEMPLATE_SIZE) {
-      console.error(`[ulpi] Warning: skipping oversized template file: ${filePath} (${stat.size} bytes)`);
-      return null;
-    }
-    const raw = fs.readFileSync(filePath, "utf-8");
-    const parsed = parseYaml(raw);
-    if (!parsed || typeof parsed !== "object" || !parsed.id) {
-      return null;
-    }
-    return {
-      id: parsed.id,
-      name: parsed.name ?? parsed.id,
-      category: parsed.category ?? "universal",
-      variables: parsed.variables ?? void 0,
-      rules: {
-        preconditions: parsed.rules?.preconditions,
-        postconditions: parsed.rules?.postconditions,
-        permissions: parsed.rules?.permissions,
-        pipelines: parsed.rules?.pipelines
-      }
-    };
-  } catch {
-    return null;
-  }
-}
-function loadBundledTemplates() {
-  const dir = findTemplatesDir();
-  return loadTemplatesFromDir(dir);
-}
-function loadTemplates(dir) {
-  return loadTemplatesFromDir(dir);
-}
-function loadTemplatesFromDir(dir) {
-  if (!fs.existsSync(dir)) {
-    return [];
-  }
-  const files = fs.readdirSync(dir).filter((f) => /\.ya?ml$/i.test(f));
-  const layers = [];
-  for (const file of files.sort()) {
-    const layer = loadTemplateFile(path.join(dir, file));
-    if (layer) {
-      layers.push(layer);
-    }
-  }
-  return layers;
-}
-function getBundledTemplate(id) {
-  const all = loadBundledTemplates();
-  return all.find((t) => t.id === id) ?? null;
-}
-function deepClone(value) {
-  if (typeof structuredClone === "function") {
-    return structuredClone(value);
-  }
-  return JSON.parse(JSON.stringify(value));
-}
-function composeTemplates(layers) {
-  const result = {
-    variables: {},
-    preconditions: {},
-    postconditions: {},
-    permissions: {},
-    pipelines: {}
-  };
-  for (const layer of layers) {
-    const cloned = deepClone(layer);
-    if (cloned.variables) {
-      Object.assign(result.variables, cloned.variables);
-    }
-    if (cloned.rules.preconditions) {
-      for (const [key, rule] of Object.entries(cloned.rules.preconditions)) {
-        result.preconditions[key] = {
-          ...result.preconditions[key],
-          ...rule,
-          id: key,
-          type: "precondition",
-          source: "template"
-        };
-      }
-    }
-    if (cloned.rules.postconditions) {
-      for (const [key, rule] of Object.entries(cloned.rules.postconditions)) {
-        result.postconditions[key] = {
-          ...result.postconditions[key],
-          ...rule,
-          id: key,
-          type: "postcondition",
-          source: "template"
-        };
-      }
-    }
-    if (cloned.rules.permissions) {
-      for (const [key, rule] of Object.entries(cloned.rules.permissions)) {
-        result.permissions[key] = {
-          ...result.permissions[key],
-          ...rule,
-          id: key,
-          type: "permission",
-          source: "template"
-        };
-      }
-    }
-    if (cloned.rules.pipelines) {
-      for (const [key, rule] of Object.entries(cloned.rules.pipelines)) {
-        result.pipelines[key] = {
-          ...result.pipelines[key],
-          ...rule,
-          id: key,
-          type: "pipeline",
-          source: "template"
-        };
-      }
-    }
-  }
-  return result;
-}
-function buildVariableMap(templateVars, config) {
-  const pm = config.package_manager ?? templateVars.package_manager ?? "npm";
-  const vars = { ...templateVars };
-  vars.package_manager = pm;
-  vars.project_name = config.name ?? vars.project_name ?? "";
-  vars.test_command = vars.test_command ?? `${pm} test`;
-  vars.lint_command = vars.lint_command ?? `${pm} lint`;
-  vars.build_command = vars.build_command ?? `${pm} build`;
-  if (config.test_command) vars.test_command = config.test_command;
-  if (config.lint_command) vars.lint_command = config.lint_command;
-  if (config.build_command) vars.build_command = config.build_command;
-  if (config.format_command) vars.format_command = config.format_command;
-  return vars;
-}
-var MAX_RESOLVE_ITERATIONS = 10;
-function resolveValue(value, vars) {
-  if (typeof value === "string") {
-    let result = value;
-    for (let pass = 0; pass < MAX_RESOLVE_ITERATIONS; pass++) {
-      const next = result.replace(
-        /\{(\w+)\}/g,
-        (_match, key) => vars[key] ?? `{${key}}`
-      );
-      if (next === result) break;
-      result = next;
-    }
-    return result;
-  }
-  if (Array.isArray(value)) {
-    return value.map((item) => resolveValue(item, vars));
-  }
-  if (value !== null && typeof value === "object") {
-    const resolved = {};
-    for (const [k, v] of Object.entries(value)) {
-      resolved[k] = resolveValue(v, vars);
-    }
-    return resolved;
-  }
-  return value;
-}
-function findUnresolvedPlaceholders(value) {
-  const found = [];
-  if (typeof value === "string") {
-    const matches = value.match(/\{(\w+)\}/g);
-    if (matches) found.push(...matches);
-  } else if (Array.isArray(value)) {
-    for (const item of value) found.push(...findUnresolvedPlaceholders(item));
-  } else if (value !== null && typeof value === "object") {
-    for (const v of Object.values(value)) {
-      found.push(...findUnresolvedPlaceholders(v));
-    }
-  }
-  return found;
-}
-function resolveTemplate(composed, config) {
-  const vars = buildVariableMap(composed.variables, config);
-  const resolved = {
-    variables: vars,
-    preconditions: resolveValue(composed.preconditions, vars),
-    postconditions: resolveValue(composed.postconditions, vars),
-    permissions: resolveValue(composed.permissions, vars),
-    pipelines: resolveValue(composed.pipelines, vars)
-  };
-  const RUNTIME_PLACEHOLDERS = /* @__PURE__ */ new Set(["{file_path}", "{command}"]);
-  const unresolved = [
-    ...findUnresolvedPlaceholders(resolved.preconditions),
-    ...findUnresolvedPlaceholders(resolved.postconditions),
-    ...findUnresolvedPlaceholders(resolved.permissions),
-    ...findUnresolvedPlaceholders(resolved.pipelines)
-  ].filter((p) => !RUNTIME_PLACEHOLDERS.has(p));
-  if (unresolved.length > 0) {
-    const unique = [...new Set(unresolved)];
-    console.error(`[ulpi] Warning: unresolved template variables after resolution: ${unique.join(", ")}`);
-  }
-  return resolved;
-}
-var DEFAULT_BASE_DIR = USER_TEMPLATES_DIR;
-function ensureDir(dir) {
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
-  }
-}
-function validateTemplateName(name) {
-  if (!name) {
-    throw new Error("Invalid template name: name is required");
-  }
-  if (name.includes("..") || name.includes("/") || name.includes("\\")) {
-    throw new Error("Invalid template name: contains path traversal characters");
-  }
-  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
-    throw new Error("Template name must be alphanumeric with hyphens/underscores only");
-  }
-  if (name.length > 100) {
-    throw new Error("Template name too long (max 100 characters)");
-  }
-}
-function templatePath(name, baseDir) {
-  validateTemplateName(name);
-  return path2.join(baseDir, `${name}.yml`);
-}
-function saveUserTemplate(template, baseDir = DEFAULT_BASE_DIR) {
-  ensureDir(baseDir);
-  const filePath = templatePath(template.name, baseDir);
-  const yaml = stringifyYaml(template, { indent: 2, lineWidth: 0 });
-  fs2.writeFileSync(filePath, yaml, "utf-8");
-}
-function loadUserTemplate(name, baseDir = DEFAULT_BASE_DIR) {
-  const filePath = templatePath(name, baseDir);
-  if (!fs2.existsSync(filePath)) {
-    return null;
-  }
-  try {
-    const raw = fs2.readFileSync(filePath, "utf-8");
-    const parsed = parseYaml2(raw);
-    if (!parsed || typeof parsed !== "object" || !parsed.name) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function listUserTemplates(baseDir = DEFAULT_BASE_DIR) {
-  if (!fs2.existsSync(baseDir)) {
-    return [];
-  }
-  const files = fs2.readdirSync(baseDir).filter((f) => /\.ya?ml$/i.test(f));
-  const templates = [];
-  for (const file of files.sort()) {
-    try {
-      const raw = fs2.readFileSync(path2.join(baseDir, file), "utf-8");
-      const parsed = parseYaml2(raw);
-      if (parsed && typeof parsed === "object" && parsed.name) {
-        templates.push(parsed);
-      }
-    } catch {
-    }
-  }
-  return templates;
-}
-function deleteUserTemplate(name, baseDir = DEFAULT_BASE_DIR) {
-  const filePath = templatePath(name, baseDir);
-  if (!fs2.existsSync(filePath)) {
-    return false;
-  }
-  fs2.unlinkSync(filePath);
-  return true;
-}
-function exportUserTemplate(name, baseDir = DEFAULT_BASE_DIR) {
-  const filePath = templatePath(name, baseDir);
-  if (!fs2.existsSync(filePath)) {
-    return null;
-  }
-  return fs2.readFileSync(filePath, "utf-8");
-}
-function importUserTemplate(yamlContent, baseDir = DEFAULT_BASE_DIR) {
-  const parsed = parseYaml2(yamlContent);
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error("Invalid YAML: expected an object");
-  }
-  if (!parsed.name || typeof parsed.name !== "string") {
-    throw new Error("Invalid template: missing 'name' field");
-  }
-  validateTemplateName(parsed.name);
-  if (!parsed.stack || typeof parsed.stack !== "object") {
-    throw new Error("Invalid template: missing 'stack' field");
-  }
-  if (!parsed.stack.runtime || typeof parsed.stack.runtime !== "string" || parsed.stack.runtime.trim() === "") {
-    throw new Error("Invalid template: stack.runtime must be a non-empty string");
-  }
-  if (parsed.layers !== void 0 && !Array.isArray(parsed.layers)) {
-    throw new Error("Invalid template: 'layers' must be an array if present");
-  }
-  if (!parsed.layers) {
-    parsed.layers = [];
-  }
-  if (!parsed.createdAt) {
-    parsed.createdAt = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  if (parsed.rules !== void 0 && (typeof parsed.rules !== "object" || parsed.rules === null)) {
-    throw new Error("Invalid template: 'rules' must be an object if present");
-  }
-  if (!parsed.rules) {
-    parsed.rules = {
-      preconditions: {},
-      postconditions: {},
-      permissions: {},
-      pipelines: {}
-    };
-  } else {
-    const rulesSections = ["preconditions", "postconditions", "permissions", "pipelines"];
-    for (const section of rulesSections) {
-      const value = parsed.rules[section];
-      if (value !== void 0 && (typeof value !== "object" || value === null || Array.isArray(value))) {
-        throw new Error(`Invalid template: rules.${section} must be an object if present`);
-      }
-    }
-    if (!parsed.rules.preconditions) parsed.rules.preconditions = {};
-    if (!parsed.rules.postconditions) parsed.rules.postconditions = {};
-    if (!parsed.rules.permissions) parsed.rules.permissions = {};
-    if (!parsed.rules.pipelines) parsed.rules.pipelines = {};
-  }
-  if (parsed.skills !== void 0 && !Array.isArray(parsed.skills)) {
-    throw new Error("Invalid template: 'skills' must be an array if present");
-  }
-  if (!parsed.skills) {
-    parsed.skills = [];
-  }
-  saveUserTemplate(parsed, baseDir);
-  return parsed;
-}
-function isWithinBase(resolved, base) {
-  const normalizedResolved = path3.resolve(resolved);
-  const normalizedBase = path3.resolve(base);
-  return normalizedResolved.startsWith(normalizedBase + path3.sep) || normalizedResolved === normalizedBase;
-}
-function loadSkillSync(skillPath, projectDir) {
-  const projectResolved = path3.resolve(projectDir, skillPath);
-  if (isWithinBase(projectResolved, projectDir)) {
-    try {
-      return fs3.readFileSync(projectResolved, "utf-8");
-    } catch {
-    }
-  }
-  const userResolved = path3.join(USER_SKILLS_DIR, path3.basename(skillPath));
-  if (isWithinBase(userResolved, USER_SKILLS_DIR)) {
-    try {
-      return fs3.readFileSync(userResolved, "utf-8");
-    } catch {
-    }
-  }
-  return null;
-}
-function injectSkill(message, skillPath, projectDir) {
-  if (!skillPath) return message;
-  const skillContent = loadSkillSync(skillPath, projectDir);
-  if (!skillContent) return message;
-  return `${message}
-
----
-
-${skillContent}`;
-}
-var BUNDLED_SKILLS = [
-  {
-    id: "conventional-commits",
-    name: "Conventional Commits",
-    description: "Guide for writing conventional commit messages",
-    filename: "conventional-commits.md",
-    category: "workflow"
-  },
-  {
-    id: "safe-migrations",
-    name: "Safe Database Migrations",
-    description: "Best practices for writing safe database migrations",
-    filename: "safe-migrations.md",
-    category: "operations"
-  },
-  {
-    id: "env-management",
-    name: "Environment Variable Management",
-    description: "Rules for managing environment variables and secrets",
-    filename: "env-management.md",
-    category: "security"
-  },
-  {
-    id: "error-handling",
-    name: "Error Handling",
-    description: "Error handling patterns and best practices",
-    filename: "error-handling.md",
-    category: "quality"
-  },
-  {
-    id: "test-writing",
-    name: "Test Writing Guide",
-    description: "Guide for writing effective tests",
-    filename: "test-writing.md",
-    category: "quality"
-  },
-  {
-    id: "code-review-checklist",
-    name: "Code Review Checklist",
-    description: "Pre-review checklist for code quality",
-    filename: "code-review-checklist.md",
-    category: "quality"
-  }
-];
-function getBundledSkillInfo(id) {
-  return BUNDLED_SKILLS.find((s) => s.id === id);
-}
-
-export {
-  loadBundledTemplates,
-  loadTemplates,
-  getBundledTemplate,
-  composeTemplates,
-  resolveTemplate,
-  saveUserTemplate,
-  loadUserTemplate,
-  listUserTemplates,
-  deleteUserTemplate,
-  exportUserTemplate,
-  importUserTemplate,
-  loadSkillSync,
-  injectSkill,
-  BUNDLED_SKILLS,
-  getBundledSkillInfo
-};