stackloom-cli 1.0.0

package/src/core/marker-strategy.js

@@ -0,0 +1,138 @@
+/**
+ * MarkerStrategy — preserves custom code during regeneration
+ */
+
+const MARKERS = {
+  // Matches the entire auto-generated block including header/footer.
+  // Note: the END line is `// END AUTO-GENERATED` (a plain comment) — it is NOT
+  // prefixed with the ═ rule, so the pattern must not expect ═ chars there.
+  block:
+    /(\/\/═+\s*[\r\n]+\/\/ AUTO-GENERATED[\s\S]*?\/\/ END AUTO-GENERATED\s*[\r\n]+\/\/═+)/m,
+
+  header: (resourceName, timestamp, stealth = false) => {
+    if (stealth)
+      return `//══════════════════════════════════════════════════════════════════════════════
+// AUTO-GENERATED — DO NOT EDIT MANUALLY
+//══════════════════════════════════════════════════════════════════════════════`;
+
+    return `//══════════════════════════════════════════════════════════════════════════════
+// AUTO-GENERATED — DO NOT EDIT MANUALLY
+// Resource: ${resourceName || "Unknown"}
+// Generated at: ${timestamp || new Date().toISOString()}
+//══════════════════════════════════════════════════════════════════════════════`;
+  },
+
+  footer: `//══════════════════════════════════════════════════════════════════════════════
+// END AUTO-GENERATED
+//══════════════════════════════════════════════════════════════════════════════`,
+};
+
+export class MarkerStrategy {
+  static parse(content) {
+    // Very flexible regex for parsing. The END line is a plain `// END
+    // AUTO-GENERATED` comment — not prefixed with the ═/- rule — so the middle
+    // segment must match `// END`, not `//═══ END`.
+    const flexibleBlock =
+      /(\/\/[═-]+\s*[\r\n]+\/\/ AUTO-GENERATED[\s\S]*?\/\/ END AUTO-GENERATED\s*[\r\n]+\/\/[═-]+)/m;
+    const blockMatch = content.match(flexibleBlock);
+
+    if (!blockMatch) {
+      return { hasMarkers: false, full: content };
+    }
+
+    const fullBlock = blockMatch[0];
+    const blockStart = blockMatch.index;
+    const blockEnd = blockStart + fullBlock.length;
+
+    const lines = fullBlock.split(/\r?\n/);
+
+    // Find auto content (between header and footer)
+    let headerEndIdx = -1;
+    let separatorCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes("════════") || lines[i].includes("--------")) {
+        separatorCount++;
+        if (separatorCount === 2) {
+          headerEndIdx = i + 1;
+          break;
+        }
+      }
+    }
+
+    let footerStartIdx = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (lines[i].includes("END AUTO-GENERATED")) {
+        footerStartIdx = i - 1;
+        break;
+      }
+    }
+
+    let autoBlock = "";
+    if (headerEndIdx > 0 && footerStartIdx > headerEndIdx) {
+      autoBlock = lines.slice(headerEndIdx, footerStartIdx).join("\n").trim();
+    }
+
+    // Look for custom zone
+    const customZoneMarker = "// ✎ CUSTOM CODE ZONE";
+    let customBlock = "";
+    const customIdx = content.indexOf(customZoneMarker);
+    if (customIdx !== -1) {
+      customBlock = content.slice(customIdx);
+    }
+
+    return {
+      hasMarkers: true,
+      prelude: content.slice(0, blockStart),
+      autoBlock,
+      customBlock,
+      epilogue: content.slice(blockEnd),
+      fullBlock,
+    };
+  }
+
+  static compose(parsed, newAutoBlock, options = {}) {
+    if (!parsed.hasMarkers) {
+      return MarkerStrategy.wrapWithMarkers(newAutoBlock, "", options);
+    }
+
+    const timestamp = new Date().toISOString();
+    const header = MARKERS.header(
+      parsed.resourceName,
+      timestamp,
+      options.stealth,
+    );
+    const footer = MARKERS.footer;
+
+    const autoSection = `${header}\n\n${newAutoBlock.trim()}\n\n${footer}`;
+
+    // Preserve existing custom code if it exists
+    const customSection = parsed.customBlock
+      ? `\n\n${parsed.customBlock}`
+      : "\n\n// ✎ CUSTOM CODE ZONE — YOUR CODE HERE\n// Add custom logic below. This section is preserved during regeneration.\n// ────────────────────────────────────────────────────────────────────────────\n";
+
+    return parsed.prelude + autoSection + customSection + parsed.epilogue;
+  }
+
+  static wrapWithMarkers(autoContent, resourceName = "", options = {}) {
+    const timestamp = new Date().toISOString();
+    const header = MARKERS.header(resourceName, timestamp, options.stealth);
+    const footer = MARKERS.footer;
+
+    const customZone =
+      "\n\n// ✎ CUSTOM CODE ZONE — YOUR CODE HERE\n// Add custom logic below. This section is preserved during regeneration.\n// ────────────────────────────────────────────────────────────────────────────\n";
+
+    return `${header}\n\n${autoContent.trim()}\n\n${footer}${customZone}`;
+  }
+
+  static ensureMarkers(content, resourceName, options = {}) {
+    if (MarkerStrategy.parse(content).hasMarkers) {
+      return content;
+    }
+    return MarkerStrategy.wrapWithMarkers(content, resourceName, options);
+  }
+
+  static extractAutoBlock(content) {
+    const parsed = MarkerStrategy.parse(content);
+    return parsed.hasMarkers ? parsed.autoBlock : content.trim();
+  }
+}

package/src/core/resource-definition.js

@@ -0,0 +1,346 @@
+/**
+ * ResourceDefinition — unified schema for all generators
+ * Central type that describes a domain resource end-to-end
+ */
+
+export class ResourceDefinition {
+  constructor({
+    name,
+    collection,
+    fields = [],
+    relations = {},
+    ui = {},
+    features = {},
+    hooks = {},
+    permissions = {},
+    options = {},
+  }) {
+    this.name = name; // 'User' | 'Product' | 'Order'
+    this.collection = collection || this.toKebabCase(name) + "s";
+    this.fields = (fields || []).map((f) => new FieldDefinition(f));
+    this.relations = relations || { belongsTo: [], hasMany: [] };
+    this.ui = ui || {};
+    this.features = features || {};
+    this.hooks = hooks || {};
+    this.permissions = permissions || {};
+    this.options = options || {};
+
+    this._mongooseType = "";
+    this._mongooseConstraints = [];
+    this._mongooseDef = "";
+
+    this.validate();
+  }
+
+  validate() {
+    if (!this.name) throw new Error("Resource name is required");
+    if (!/^[A-Z][a-zA-Z0-9]*$/.test(this.name)) {
+      throw new Error(
+        `Resource name "${this.name}" must be PascalCase (start uppercase, alphanumeric)`,
+      );
+    }
+
+    // Validate field names unique
+    const fieldNames = this.fields.map((f) => f.name);
+    const duplicates = fieldNames.filter(
+      (name, i) => fieldNames.indexOf(name) !== i,
+    );
+    if (duplicates.length)
+      throw new Error(`Duplicate fields: ${duplicates.join(", ")}`);
+  }
+
+  // ── Naming helpers ────────────────────────────────────────────────────────
+  get pascalName() {
+    return this.name;
+  }
+  get camelName() {
+    return this.name[0].toLowerCase() + this.name.slice(1);
+  }
+  get snakeName() {
+    return this.camelName.replace(/[A-Z]/g, (m) => "_" + m.toLowerCase());
+  }
+  get kebabName() {
+    return this.camelName.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+  }
+  get pluralKebab() {
+    return this.kebabName + "s";
+  }
+  get pluralPascal() {
+    return this.pascalName + "s";
+  }
+
+  // ── Computed flags ────────────────────────────────────────────────────────
+  get hasTimestamps() {
+    return true;
+  } // always include createdAt, updatedAt
+  get hasSoftDelete() {
+    return this.features && this.features.softDelete === true;
+  }
+  get hasAuditLog() {
+    return this.features && this.features.auditLog === true;
+  }
+  get hasAuth() {
+    return this.features && this.features.auth !== false;
+  } // default true
+
+  // ── Indexes ───────────────────────────────────────────────────────────────
+  get indexes() {
+    const idxs = [];
+    this.fields.forEach((f) => {
+      if (f.validation && f.validation.unique)
+        idxs.push({ [f.name]: 1 }, { unique: true });
+      if (f.type === "text" || f.type === "richtext")
+        idxs.push({ [f.name]: "text" });
+    });
+    return idxs;
+  }
+
+  toKebabCase(str) {
+    if (!str) return "";
+    return str
+      .replace(/([a-z])([A-Z])/g, "$1-$2")
+      .replace(/[\s_]+/g, "-")
+      .toLowerCase();
+  }
+}
+
+export class FieldDefinition {
+  constructor(data) {
+    this.name = data.name;
+    this.type = data.type || "string";
+    this.validation = data.validation || {};
+    this.special = data.special || {};
+    this.ui = data.ui || {};
+
+    // Derived properties
+    this.formInputType = fieldTypeToFormInput(this.type);
+    this.mongooseType = fieldTypeToMongoose(this.type);
+    this._mongooseConstraints = this.buildMongooseConstraints();
+    this.joiRule = this.buildJoiRule();
+  }
+
+  get mongooseDef() {
+    return this._mongooseConstraints.join(', ');
+  }
+
+  buildJoiRule() {
+    let rule = "Joi.";
+    const v = this.validation;
+
+    switch (this.type) {
+      case "number":
+      case "range":
+        rule += "number()";
+        if (v.min !== undefined) rule += `.min(${v.min})`;
+        if (v.max !== undefined) rule += `.max(${v.max})`;
+        break;
+      case "boolean":
+        rule += "boolean()";
+        break;
+      case "date":
+      case "datetime":
+        rule += "date()";
+        break;
+      case "email":
+        rule += "string().email()";
+        break;
+      case "password":
+        rule += "string().min(8)";
+        break;
+      default:
+        rule += "string()";
+        if (v.minLength !== undefined) rule += `.min(${v.minLength})`;
+        if (v.maxLength !== undefined) rule += `.max(${v.maxLength})`;
+        if (v.pattern) rule += `.pattern(${v.pattern})`;
+    }
+
+    if (v.required) rule += ".required()";
+    else rule += ".optional()";
+
+    if (v.default !== undefined) {
+      const val = typeof v.default === "string" ? `'${v.default}'` : v.default;
+      rule += `.default(${val})`;
+    }
+
+    return rule;
+  }
+
+  buildMongooseConstraints() {
+    const c = [];
+    const v = this.validation;
+
+    // Always include type
+    c.push(`type: ${this.mongooseType}`);
+
+    if (v.required) c.push("required: true");
+    if (v.unique) c.push("unique: true");
+    if (v.default !== undefined) {
+      const val = typeof v.default === "string" ? `'${v.default}'` : v.default;
+      c.push(`default: ${val}`);
+    }
+
+    if (this.type === "number" || this.type === "range") {
+      if (v.min !== undefined) c.push(`min: ${v.min}`);
+      if (v.max !== undefined) c.push(`max: ${v.max}`);
+    }
+
+    if (this.type === "string" || this.type === "text") {
+      if (v.minLength !== undefined) c.push(`minLength: ${v.minLength}`);
+      if (v.maxLength !== undefined) c.push(`maxLength: ${v.maxLength}`);
+      if (v.pattern) c.push(`match: ${v.pattern}`);
+    }
+
+    if (this.type === "ref" || this.type === "reference") {
+      if (this.special && this.special.model)
+        c.push(`ref: '${this.special.model}'`);
+    }
+
+    return c;
+  }
+}
+
+/**
+ * Map our unified types to Mongoose types
+ */
+export function fieldTypeToMongoose(type) {
+  const map = {
+    string: "String",
+    text: "String",
+    number: "Number",
+    boolean: "Boolean",
+    date: "Date",
+    datetime: "Date",
+    email: "String",
+    password: "String",
+    ref: "mongoose.Schema.Types.ObjectId",
+    reference: "mongoose.Schema.Types.ObjectId",
+    array: "Array",
+    object: "Object",
+    image: "String",
+    file: "String",
+  };
+  return map[type] || "String";
+}
+
+/**
+ * parseFieldSpec — parses a compact string representation of a field
+ */
+export function parseFieldSpec(spec) {
+  if (!spec || typeof spec !== "string") return null;
+
+  const match = spec.match(
+    /^([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:\s*([a-zA-Z]+)(?:\[(.*?)\])?(?:[:|](.*))?$/,
+  );
+  if (!match) {
+    console.warn(
+      `[WARN] Could not parse field spec: "${spec}". Expected format: name:type[options]`,
+    );
+    return null;
+  }
+
+  const [, name, typeRaw, optionsRaw, rulesRaw] = match;
+
+  const field = {
+    name,
+    type: typeRaw.toLowerCase(),
+    validation: {},
+    special: {},
+    ui: {},
+  };
+
+  // Aliases
+  if (field.type === "str") field.type = "string";
+  if (field.type === "num") field.type = "number";
+  if (field.type === "bool") field.type = "boolean";
+
+  // Parse options in brackets [...]
+  if (optionsRaw) {
+    if (field.type === "ref" || field.type === "reference") {
+      field.special.model = optionsRaw.trim();
+    } else if (field.type === "select" || field.type === "multiselect") {
+      field.special.options = optionsRaw.split(",").map((o) => o.trim());
+    } else if (field.type === "image" || field.type === "file") {
+      const opts = optionsRaw.split(";");
+      field.special.upload = opts[0]?.trim() || field.type + "s";
+      if (opts[1]) {
+        const [k, v] = opts[1].split("=");
+        if (k === "max") field.special.maxSize = v;
+      }
+    } else {
+      const parts = optionsRaw.split(",").map((p) => p.trim());
+      parts.forEach((part) => {
+        if (part.includes("=")) {
+          const [k, v] = part.split("=");
+          if (k === "min") field.validation.min = parseFloat(v);
+          else if (k === "max") field.validation.max = parseFloat(v);
+          else if (k === "minLength") field.validation.minLength = parseInt(v);
+          else if (k === "maxLength") field.validation.maxLength = parseInt(v);
+          else if (k === "pattern") field.validation.pattern = v;
+          else if (k === "default") field.validation.default = v;
+        } else {
+          if (part === "required") field.validation.required = true;
+          else if (part === "unique") field.validation.unique = true;
+        }
+      });
+    }
+  }
+
+  if (rulesRaw) {
+    const rules = rulesRaw.split("|").map((r) => r.trim());
+    rules.forEach((rule) => {
+      if (rule === "required") field.validation.required = true;
+      else if (rule === "unique") field.validation.unique = true;
+      else if (rule.startsWith("min="))
+        field.validation.min = parseFloat(rule.split("=")[1]);
+      else if (rule.startsWith("max="))
+        field.validation.max = parseFloat(rule.split("=")[1]);
+      else if (rule.startsWith("minLength="))
+        field.validation.minLength = parseInt(rule.split("=")[1]);
+      else if (rule.startsWith("maxLength="))
+        field.validation.maxLength = parseInt(rule.split("=")[1]);
+      else if (rule.startsWith("default="))
+        field.validation.default = rule.split("=").slice(1).join("=");
+    });
+  }
+
+  return field;
+}
+
+function parseKeyValue(str) {
+  const result = {};
+  if (!str) return result;
+
+  const pairs = str.split(",");
+  pairs.forEach((pair) => {
+    const [key, ...valParts] = pair.split("=");
+    if (key && valParts.length > 0) {
+      result[key.trim()] = valParts.join("=").trim();
+    }
+  });
+  return result;
+}
+
+export function fieldTypeToFormInput(type) {
+  const map = {
+    string: "text",
+    text: "textarea",
+    number: "number",
+    boolean: "checkbox",
+    date: "date",
+    email: "email",
+    phone: "tel",
+    url: "url",
+    datetime: "datetime-local",
+    time: "time",
+    color: "color",
+    file: "file",
+    password: "password",
+    range: "range",
+    select: "select",
+    multiselect: "multiselect",
+    reference: "select",
+    ref: "select",
+    image: "image-upload",
+  };
+  return map[type] || "text";
+}

package/src/core/state-tracker.js

@@ -0,0 +1,67 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+/**
+ * StateTracker — tracks generated files for rollbacks
+ */
+export class StateTracker {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.stateDir = path.join(projectRoot, '.loom');
+    this.stateFile = path.join(this.stateDir, 'state.json');
+  }
+
+  async ensureStateDir() {
+    await fs.ensureDir(this.stateDir);
+  }
+
+  async loadState() {
+    if (!(await fs.pathExists(this.stateFile))) {
+      return { history: [] };
+    }
+    try {
+      return await fs.readJSON(this.stateFile);
+    } catch {
+      return { history: [] };
+    }
+  }
+
+  async saveState(state) {
+    await this.ensureStateDir();
+    await fs.writeJSON(this.stateFile, state, { spaces: 2 });
+  }
+
+  /**
+   * Record a new generation event
+   */
+  async recordEvent(event) {
+    const state = await this.loadState();
+    const newEvent = {
+      id: Date.now().toString(),
+      timestamp: new Date().toISOString(),
+      ...event, // { action: 'generate', resource: 'User', files: [...] }
+    };
+    state.history.unshift(newEvent);
+    // Keep only last 10 events
+    if (state.history.length > 10) state.history.pop();
+    await this.saveState(state);
+    return newEvent.id;
+  }
+
+  /**
+   * Get last event
+   */
+  async getLastEvent() {
+    const state = await this.loadState();
+    return state.history[0] || null;
+  }
+
+  /**
+   * Remove event by ID
+   */
+  async removeEvent(id) {
+    const state = await this.loadState();
+    state.history = state.history.filter(e => e.id !== id);
+    await this.saveState(state);
+  }
+}