@thanh01.pmt/curriculum-kit 1.0.0

package/dist/storage/index.mjs

@@ -0,0 +1,583 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import { createClient } from '@supabase/supabase-js';
+
+// src/storage/fileSystemCurriculumAdapter.ts
+function computeContentHash(content) {
+  return "sha256:" + crypto.createHash("sha256").update(content.trim(), "utf-8").digest("hex");
+}
+var STANDARD_SOT_FILES = [
+  "PROJECT_BRIEF.md",
+  "LEARNER_PROFILE.md",
+  "CURRICULUM_FRAMEWORK.md",
+  "PROJECT_STATUS.md",
+  "CONTENT_STYLE_GUIDE.md",
+  "ART_DIRECTION.md",
+  "REFERENCE_PACK.md"
+];
+var FileSystemCurriculumAdapter = class {
+  baseDir;
+  constructor(options = {}) {
+    this.baseDir = options.baseDir || path.resolve(process.cwd(), "output", "projects");
+  }
+  getProjectDir(projectId) {
+    const raw = (projectId || "").replace("proj_", "");
+    const directPath = path.join(this.baseDir, raw);
+    if (fs.existsSync(directPath)) return directPath;
+    const fullIdPath = path.join(this.baseDir, projectId);
+    if (fs.existsSync(fullIdPath)) return fullIdPath;
+    return directPath;
+  }
+  /** Ensures the resolved path stays within the project directory (prevents path traversal). */
+  assertInsideProject(projectDir, targetPath) {
+    const resolvedProject = path.resolve(projectDir);
+    const resolvedTarget = path.resolve(targetPath);
+    if (!resolvedTarget.startsWith(resolvedProject + path.sep) && resolvedTarget !== resolvedProject) {
+      throw new Error(`[FileSystemCurriculumAdapter] Path traversal blocked: ${targetPath} is outside project directory ${projectDir}`);
+    }
+  }
+  async projectExists(projectId) {
+    return fs.existsSync(this.getProjectDir(projectId));
+  }
+  async readSotDocument(projectId, filename) {
+    const projectDir = this.getProjectDir(projectId);
+    const possiblePaths = [
+      path.join(projectDir, "_sot", filename),
+      path.join(projectDir, filename)
+    ];
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+        return fs.readFileSync(p, "utf-8");
+      }
+    }
+    return null;
+  }
+  async listSotDocuments(projectId) {
+    const projectDir = this.getProjectDir(projectId);
+    const sotDir = path.join(projectDir, "_sot");
+    return STANDARD_SOT_FILES.map((filename) => {
+      const p = fs.existsSync(path.join(sotDir, filename)) ? path.join(sotDir, filename) : fs.existsSync(path.join(projectDir, filename)) ? path.join(projectDir, filename) : null;
+      if (p && fs.existsSync(p)) {
+        const stats = fs.statSync(p);
+        return {
+          name: filename.replace(".md", "").replace(/_/g, " "),
+          filename,
+          exists: true,
+          sizeBytes: stats.size
+        };
+      }
+      return {
+        name: filename.replace(".md", "").replace(/_/g, " "),
+        filename,
+        exists: false,
+        sizeBytes: 0
+      };
+    });
+  }
+  async readArtifact(projectId, relPathOrIdentifier) {
+    const projectDir = this.getProjectDir(projectId);
+    const directCandidate = path.join(projectDir, relPathOrIdentifier);
+    this.assertInsideProject(projectDir, directCandidate);
+    const possiblePaths = [
+      directCandidate,
+      path.join(projectDir, "_sot", relPathOrIdentifier),
+      path.join(projectDir, "lessons", relPathOrIdentifier),
+      path.join(projectDir, "_sot", path.basename(relPathOrIdentifier)),
+      path.join(projectDir, "lessons", path.basename(relPathOrIdentifier))
+    ];
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p) && fs.statSync(p).isFile()) {
+        return fs.readFileSync(p, "utf-8");
+      }
+    }
+    if (relPathOrIdentifier.includes(".md") || relPathOrIdentifier.includes("/")) {
+      return null;
+    }
+    const lessonMatch = relPathOrIdentifier.match(/U\d+_M\d+_L\d+/i);
+    if (lessonMatch) {
+      const lessonId = lessonMatch[0].toUpperCase();
+      const lessonDir = path.join(projectDir, "lessons", lessonId);
+      if (fs.existsSync(lessonDir) && fs.statSync(lessonDir).isDirectory()) {
+        const lower = relPathOrIdentifier.toLowerCase();
+        let artifactPrefix = "LESSON";
+        if (lower.includes("act") || lower.includes("lab") || lower.includes("th\u1EF1c h\xE0nh")) {
+          artifactPrefix = "ACT";
+        } else if (lower.includes("quiz") || lower.includes("tr\u1EAFc nghi\u1EC7m") || lower.includes("\u0111\xE1nh gi\xE1")) {
+          artifactPrefix = "QUIZ";
+        } else if (lower.includes("slide") || lower.includes("b\xE0i gi\u1EA3ng") || lower.includes("tr\xECnh chi\u1EBFu")) {
+          artifactPrefix = "SLIDE";
+        } else if (lower.includes("guide") || lower.includes("h\u01B0\u1EDBng d\u1EABn")) {
+          artifactPrefix = "GUIDE";
+        } else if (lower.includes("wks") || lower.includes("worksheet") || lower.includes("phi\u1EBFu b\xE0i t\u1EADp")) {
+          artifactPrefix = "WKS";
+        } else if (lower.includes("handout") || lower.includes("t\xE0i li\u1EC7u")) {
+          artifactPrefix = "HANDOUT";
+        } else if (lower.includes("code")) {
+          artifactPrefix = "CODE";
+        } else if (lower.includes("ext") || lower.includes("extension")) {
+          artifactPrefix = "EXT";
+        }
+        const candidateFile = path.join(lessonDir, `${artifactPrefix}_${lessonId}.md`);
+        if (fs.existsSync(candidateFile)) {
+          return fs.readFileSync(candidateFile, "utf-8");
+        }
+      }
+    }
+    return null;
+  }
+  async saveArtifact(projectId, relPath, content) {
+    const projectDir = this.getProjectDir(projectId);
+    const targetPath = path.join(projectDir, relPath);
+    this.assertInsideProject(projectDir, targetPath);
+    const targetDir = path.dirname(targetPath);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    if (fs.existsSync(targetPath)) {
+      try {
+        const oldContent = fs.readFileSync(targetPath, "utf-8");
+        if (oldContent !== content) {
+          const historyDir = path.join(projectDir, ".history", relPath);
+          fs.mkdirSync(historyDir, { recursive: true });
+          fs.writeFileSync(path.join(historyDir, `${Date.now()}.md`), oldContent, "utf-8");
+          const versions = fs.readdirSync(historyDir).filter((f) => f.endsWith(".md")).sort();
+          while (versions.length > 10) {
+            fs.unlinkSync(path.join(historyDir, versions.shift()));
+          }
+        }
+      } catch (histErr) {
+        console.warn("[FileSystemCurriculumAdapter] version history snapshot failed:", histErr?.message || histErr);
+      }
+    }
+    fs.writeFileSync(targetPath, content, "utf-8");
+    const filename = path.basename(relPath);
+    const match = filename.match(/(LESSON|ACT|QUIZ|SLIDE|GUIDE|HANDOUT|WKS|EXT)_(U\d+_M\d+_L\d+)\.md/i);
+    if (match) {
+      const lessonId = match[2].toUpperCase();
+      const lessonsDir = path.join(projectDir, "lessons", lessonId);
+      if (!fs.existsSync(lessonsDir)) {
+        fs.mkdirSync(lessonsDir, { recursive: true });
+      }
+      fs.writeFileSync(path.join(lessonsDir, filename), content, "utf-8");
+      const legacyContentDir = path.join(projectDir, "_content", lessonId);
+      if (fs.existsSync(legacyContentDir)) {
+        fs.writeFileSync(path.join(legacyContentDir, filename), content, "utf-8");
+      }
+    }
+  }
+  async listLessons(projectId) {
+    const lessonsDir = path.join(this.getProjectDir(projectId), "lessons");
+    if (!fs.existsSync(lessonsDir)) return [];
+    const lessonFolders = fs.readdirSync(lessonsDir).filter((f) => !f.startsWith("."));
+    return lessonFolders.map((folder) => {
+      const lDir = path.join(lessonsDir, folder);
+      const isDir = fs.statSync(lDir).isDirectory();
+      if (!isDir) {
+        return {
+          lessonId: folder,
+          artifactsCount: 0,
+          isComplete: false,
+          artifacts: []
+        };
+      }
+      const artifacts = fs.readdirSync(lDir).filter((f) => !f.startsWith("."));
+      return {
+        lessonId: folder,
+        artifactsCount: artifacts.length,
+        isComplete: artifacts.length >= 4,
+        artifacts
+      };
+    });
+  }
+  async getProjectStatus(projectId) {
+    const sotList = await this.listSotDocuments(projectId);
+    const lessons = await this.listLessons(projectId);
+    const completedCount = lessons.filter((l) => l.isComplete).length;
+    const totalLessons = lessons.length || 4;
+    const progressPercent = Math.round(completedCount / totalLessons * 100);
+    const sotTable = sotList.map((doc) => `| \`${doc.filename}\` | ${doc.exists ? "\u2705 S\u1EB5n s\xE0ng" : "\u274C Ch\u01B0a c\xF3"} |`).join("\n");
+    const lessonTable = lessons.length > 0 ? lessons.map((l) => `| **${l.lessonId}** | ${l.artifactsCount}/4 Artifacts | ${l.isComplete ? "\u2705 Ho\xE0n t\u1EA5t" : "\u23F3 \u0110ang t\u1EA1o sinh"} | ${l.artifacts.join(", ") || "-"} |`).join("\n") : "| Ch\u01B0a c\xF3 b\xE0i h\u1ECDc n\xE0o tr\xEAn \u0111\u0129a c\u1EE9ng | 0/4 | \u23F3 Ch\u1EDD ch\u1EA1y | - |";
+    const rawMarkdownReport = `## \u{1F4CA} B\xC1O C\xC1O TR\u1EA0NG TH\xC1I D\u1EF0 \xC1N: \`${projectId.toUpperCase()}\`
+
+### 1. N\u1EC1n t\u1EA3ng T\xE0i li\u1EC7u (SOT Readiness)
+| T\xE0i li\u1EC7u SOT | Tr\u1EA1ng th\xE1i |
+|---|:---:|
+${sotTable}
+
+### 2. Danh m\u1EE5c B\xE0i h\u1ECDc & H\u1ECDc li\u1EC7u (Lessons & Artifacts Matrix)
+| M\xE3 b\xE0i h\u1ECDc | S\u1ED1 l\u01B0\u1EE3ng Artifact | Tr\u1EA1ng th\xE1i | Danh s\xE1ch Artifact \u0111\xE3 t\u1EA1o |
+|---|:---:|:---:|---|
+${lessonTable}
+
+**Ti\u1EBFn \u0111\u1ED9 t\u1ED5ng th\u1EC3:** ${completedCount}/${totalLessons} b\xE0i h\u1ECDc (${progressPercent}%)
+
+### 3. \u0110\u1EC1 xu\u1EA5t H\xE0nh \u0111\u1ED9ng Ti\u1EBFp theo:
+- S\u1EED d\u1EE5ng l\u1EC7nh \`/create-lesson <id>\` \u0111\u1EC3 t\u1EA1o sinh c\xE1c b\xE0i h\u1ECDc ti\u1EBFp theo trong pipeline.
+- S\u1EED d\u1EE5ng l\u1EC7nh \`/audit-quality\` \u0111\u1EC3 ch\u1EA1y ki\u1EC3m th\u1EED ti\xEAu chu\u1EA9n Bloom v\xE0 Alignment Matrix.`;
+    return {
+      projectId,
+      sotReadiness: sotList,
+      lessons,
+      completedCount,
+      totalLessons,
+      progressPercent,
+      rawMarkdownReport
+    };
+  }
+  async getPipelineState(projectId) {
+    const projectDir = this.getProjectDir(projectId);
+    const stateFile = path.join(projectDir, "_pipeline", "state.json");
+    if (fs.existsSync(stateFile)) {
+      try {
+        const raw = fs.readFileSync(stateFile, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && parsed.tasks) {
+          return parsed;
+        }
+      } catch (err) {
+        console.warn(`[FileSystemCurriculumAdapter] Error reading pipeline state for ${projectId}:`, err);
+      }
+    }
+    return {
+      projectId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tasks: {}
+    };
+  }
+  async savePipelineState(projectId, state) {
+    const projectDir = this.getProjectDir(projectId);
+    const pipelineDir = path.join(projectDir, "_pipeline");
+    if (!fs.existsSync(pipelineDir)) {
+      fs.mkdirSync(pipelineDir, { recursive: true });
+    }
+    const stateFile = path.join(pipelineDir, "state.json");
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    fs.writeFileSync(stateFile, JSON.stringify(state, null, 2), "utf-8");
+  }
+  async updateArtifactState(projectId, taskId, artifactType, update) {
+    const current = await this.getPipelineState(projectId);
+    if (!current.tasks[taskId]) {
+      current.tasks[taskId] = {};
+    }
+    const existingInfo = current.tasks[taskId][artifactType] || {
+      state: "pending"
+    };
+    current.tasks[taskId][artifactType] = {
+      ...existingInfo,
+      ...update
+    };
+    await this.savePipelineState(projectId, current);
+    return current;
+  }
+};
+var SupabaseCurriculumAdapter = class {
+  client;
+  bucketName;
+  constructor(config = {}) {
+    this.bucketName = config.bucketName || process.env.SUPABASE_STORAGE_BUCKET || "course-materials";
+    if (config.client) {
+      this.client = config.client;
+    } else {
+      const url = config.supabaseUrl || process.env.NEXT_PUBLIC_SUPABASE_URL || process.env.SUPABASE_URL || "";
+      const key = config.supabaseServiceRoleKey || process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "";
+      if (!url || !key) {
+        throw new Error("Supabase URL or Key is missing in SupabaseCurriculumAdapter");
+      }
+      this.client = createClient(url, key);
+    }
+  }
+  async projectExists(projectId) {
+    try {
+      const { data, error } = await this.client.storage.from(this.bucketName).list(projectId, { limit: 5 });
+      return !error && !!data && data.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  async readSotDocument(projectId, filename) {
+    const paths = [
+      `${projectId}/_sot/${filename}`,
+      `${projectId}/${filename}`,
+      `${projectId}/_designer/${filename}`,
+      `${projectId}/_analyst/${filename}`
+    ];
+    for (const p of paths) {
+      try {
+        const { data, error } = await this.client.storage.from(this.bucketName).download(p);
+        if (!error && data) {
+          return await data.text();
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  async listSotDocuments(projectId) {
+    const results = [];
+    for (const filename of STANDARD_SOT_FILES) {
+      const content = await this.readSotDocument(projectId, filename);
+      results.push({
+        name: filename.replace(".md", "").replace(/_/g, " "),
+        filename,
+        exists: !!content,
+        content: content || void 0,
+        sizeBytes: content ? content.length : 0
+      });
+    }
+    return results;
+  }
+  async readArtifact(projectId, relPathOrIdentifier) {
+    const cleanPath = relPathOrIdentifier.replace(/^\//, "");
+    const possiblePaths = [
+      `${projectId}/${cleanPath}`,
+      `${projectId}/_sot/${cleanPath}`,
+      `${projectId}/_content/${cleanPath}`,
+      `${projectId}/lessons/${cleanPath}`,
+      `${projectId}/_sot/${cleanPath.split("/").pop()}`,
+      `${projectId}/lessons/${cleanPath.split("/").pop()}`
+    ];
+    for (const p of possiblePaths) {
+      try {
+        const { data, error } = await this.client.storage.from(this.bucketName).download(p);
+        if (!error && data) {
+          return await data.text();
+        }
+      } catch {
+      }
+    }
+    const lessonMatch = relPathOrIdentifier.match(/U\d+_M\d+_L\d+/i);
+    if (lessonMatch) {
+      const lessonId = lessonMatch[0].toUpperCase();
+      const unitCode = lessonId.split("_")[0] || "U01";
+      const lower = relPathOrIdentifier.toLowerCase();
+      let artifactPrefix = "LESSON";
+      if (lower.includes("act") || lower.includes("lab") || lower.includes("th\u1EF1c h\xE0nh")) {
+        artifactPrefix = "ACT";
+      } else if (lower.includes("quiz") || lower.includes("tr\u1EAFc nghi\u1EC7m") || lower.includes("\u0111\xE1nh gi\xE1")) {
+        artifactPrefix = "QUIZ";
+      } else if (lower.includes("slide") || lower.includes("b\xE0i gi\u1EA3ng") || lower.includes("tr\xECnh chi\u1EBFu")) {
+        artifactPrefix = "SLIDE";
+      } else if (lower.includes("guide") || lower.includes("h\u01B0\u1EDBng d\u1EABn")) {
+        artifactPrefix = "GUIDE";
+      }
+      const candidatePaths = [
+        `${projectId}/_content/${unitCode}/${artifactPrefix}_${lessonId}.md`,
+        `${projectId}/lessons/${lessonId}/${artifactPrefix}_${lessonId}.md`,
+        `${projectId}/${artifactPrefix}_${lessonId}.md`
+      ];
+      for (const p of candidatePaths) {
+        try {
+          const { data, error } = await this.client.storage.from(this.bucketName).download(p);
+          if (!error && data) {
+            return await data.text();
+          }
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
+  async saveArtifact(projectId, relPath, content) {
+    const fullPath = `${projectId}/${relPath.replace(/^\//, "")}`;
+    const { error } = await this.client.storage.from(this.bucketName).upload(fullPath, Buffer.from(content, "utf-8"), {
+      contentType: "text/markdown",
+      upsert: true
+    });
+    if (error) {
+      throw new Error(`Failed to upload artifact to Supabase Storage: ${error.message}`);
+    }
+    try {
+      await this.client.from("curriculum_artifacts").upsert({
+        project_id: projectId,
+        rel_path: relPath,
+        content,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      }, { onConflict: "project_id,rel_path" });
+    } catch {
+    }
+  }
+  async listLessons(projectId) {
+    const summaries = [];
+    const processedLessons = /* @__PURE__ */ new Set();
+    try {
+      const { data: unitDirs } = await this.client.storage.from(this.bucketName).list(`${projectId}/_content`);
+      if (unitDirs) {
+        for (const u of unitDirs) {
+          const { data: files } = await this.client.storage.from(this.bucketName).list(`${projectId}/_content/${u.name}`);
+          if (files) {
+            const lessonMap = {};
+            files.forEach((f) => {
+              const m = f.name.match(/U\d+_M\d+_L\d+/i);
+              if (m) {
+                const lid = m[0].toUpperCase();
+                lessonMap[lid] = lessonMap[lid] || [];
+                lessonMap[lid].push(f.name);
+              }
+            });
+            for (const [lid, arts] of Object.entries(lessonMap)) {
+              if (!processedLessons.has(lid)) {
+                processedLessons.add(lid);
+                summaries.push({
+                  lessonId: lid,
+                  artifactsCount: arts.length,
+                  isComplete: arts.length >= 4,
+                  artifacts: arts
+                });
+              }
+            }
+          }
+        }
+      }
+      const { data: lessonDirs } = await this.client.storage.from(this.bucketName).list(`${projectId}/lessons`);
+      if (lessonDirs) {
+        for (const dir of lessonDirs) {
+          if (!processedLessons.has(dir.name)) {
+            const { data: files } = await this.client.storage.from(this.bucketName).list(`${projectId}/lessons/${dir.name}`);
+            const artifacts = (files || []).map((f) => f.name).filter((n) => !n.startsWith("."));
+            processedLessons.add(dir.name);
+            summaries.push({
+              lessonId: dir.name,
+              artifactsCount: artifacts.length,
+              isComplete: artifacts.length >= 4,
+              artifacts
+            });
+          }
+        }
+      }
+    } catch {
+    }
+    return summaries;
+  }
+  async getProjectStatus(projectId) {
+    const sotList = await this.listSotDocuments(projectId);
+    const lessons = await this.listLessons(projectId);
+    const completedCount = lessons.filter((l) => l.isComplete).length;
+    const totalLessons = lessons.length || 4;
+    const progressPercent = Math.round(completedCount / totalLessons * 100);
+    const sotTable = sotList.map((doc) => `| \`${doc.filename}\` | ${doc.exists ? "\u2705 S\u1EB5n s\xE0ng" : "\u274C Ch\u01B0a c\xF3"} |`).join("\n");
+    const lessonTable = lessons.length > 0 ? lessons.map((l) => `| **${l.lessonId}** | ${l.artifactsCount}/4 Artifacts | ${l.isComplete ? "\u2705 Ho\xE0n t\u1EA5t" : "\u23F3 \u0110ang t\u1EA1o sinh"} | ${l.artifacts.join(", ") || "-"} |`).join("\n") : "| Ch\u01B0a c\xF3 b\xE0i h\u1ECDc n\xE0o tr\xEAn cloud storage | 0/4 | \u23F3 Ch\u1EDD ch\u1EA1y | - |";
+    const rawMarkdownReport = `## \u{1F4CA} B\xC1O C\xC1O TR\u1EA0NG TH\xC1I D\u1EF0 \xC1N (CLOUD): \`${projectId.toUpperCase()}\`
+
+### 1. N\u1EC1n t\u1EA3ng T\xE0i li\u1EC7u (SOT Readiness)
+| T\xE0i li\u1EC7u SOT | Tr\u1EA1ng th\xE1i |
+|---|:---:|
+${sotTable}
+
+### 2. Danh m\u1EE5c B\xE0i h\u1ECDc & H\u1ECDc li\u1EC7u (Lessons & Artifacts Matrix)
+| M\xE3 b\xE0i h\u1ECDc | S\u1ED1 l\u01B0\u1EE3ng Artifact | Tr\u1EA1ng th\xE1i | Danh s\xE1ch Artifact \u0111\xE3 t\u1EA1o |
+|---|:---:|:---:|---|
+${lessonTable}
+
+**Ti\u1EBFn \u0111\u1ED9 t\u1ED5ng th\u1EC3:** ${completedCount}/${totalLessons} b\xE0i h\u1ECDc (${progressPercent}%)`;
+    return {
+      projectId,
+      sotReadiness: sotList,
+      lessons,
+      completedCount,
+      totalLessons,
+      progressPercent,
+      rawMarkdownReport
+    };
+  }
+  /**
+   * Uploads a complete milestone bundle (Markdown files) to Supabase Storage
+   */
+  async uploadMilestoneBundle(projectSlug, bundle) {
+    const basePath = `${projectSlug}/${bundle.milestoneId}`;
+    const uploads = [
+      {
+        path: `${basePath}/LESSON.md`,
+        content: bundle.lessonMarkdown,
+        type: "text/markdown"
+      },
+      {
+        path: `${basePath}/ACT.md`,
+        content: bundle.activityMarkdown,
+        type: "text/markdown"
+      },
+      {
+        path: `${basePath}/HANDOUT.md`,
+        content: bundle.handoutMarkdown,
+        type: "text/markdown"
+      }
+    ];
+    const results = {};
+    for (const item of uploads) {
+      const { data, error } = await this.client.storage.from(this.bucketName).upload(item.path, Buffer.from(item.content, "utf-8"), {
+        contentType: item.type,
+        upsert: true
+      });
+      if (!error && data) {
+        const { data: publicUrlData } = this.client.storage.from(this.bucketName).getPublicUrl(item.path);
+        results[item.path] = publicUrlData.publicUrl;
+      }
+    }
+    return {
+      lessonUrl: results[`${basePath}/LESSON.md`],
+      activityUrl: results[`${basePath}/ACT.md`],
+      handoutUrl: results[`${basePath}/HANDOUT.md`]
+    };
+  }
+  async getPipelineState(projectId) {
+    const p = `${projectId}/_pipeline/state.json`;
+    try {
+      const { data, error } = await this.client.storage.from(this.bucketName).download(p);
+      if (!error && data) {
+        const text = await data.text();
+        return JSON.parse(text);
+      }
+    } catch {
+    }
+    return {
+      projectId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      tasks: {}
+    };
+  }
+  async savePipelineState(projectId, state) {
+    const p = `${projectId}/_pipeline/state.json`;
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.client.storage.from(this.bucketName).upload(p, Buffer.from(JSON.stringify(state, null, 2), "utf-8"), {
+      contentType: "application/json",
+      upsert: true
+    });
+  }
+  async updateArtifactState(projectId, taskId, artifactType, update) {
+    const current = await this.getPipelineState(projectId);
+    if (!current.tasks[taskId]) {
+      current.tasks[taskId] = {};
+    }
+    current.tasks[taskId][artifactType] = {
+      ...current.tasks[taskId][artifactType] || { state: "pending" },
+      ...update
+    };
+    await this.savePipelineState(projectId, current);
+    return current;
+  }
+};
+
+// src/storage/factory.ts
+function createCurriculumStorage(options = {}) {
+  const provider = options.provider || process.env.CURRICULUM_STORAGE_PROVIDER || "auto";
+  if (provider === "supabase") {
+    return new SupabaseCurriculumAdapter(options.supabaseConfig);
+  }
+  if (provider === "auto") {
+    const hasSupabase = Boolean(
+      (process.env.SUPABASE_URL || process.env.NEXT_PUBLIC_SUPABASE_URL) && (process.env.SUPABASE_SERVICE_ROLE_KEY || process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY) && process.env.STORAGE_USE_SUPABASE === "true"
+    );
+    if (hasSupabase) {
+      try {
+        return new SupabaseCurriculumAdapter(options.supabaseConfig);
+      } catch (e) {
+        console.warn("\u26A0\uFE0F Falling back to FileSystemCurriculumAdapter due to Supabase initialization error:", e);
+      }
+    }
+  }
+  return new FileSystemCurriculumAdapter(options.fileSystemOptions);
+}
+
+export { FileSystemCurriculumAdapter, STANDARD_SOT_FILES, SupabaseCurriculumAdapter, computeContentHash, createCurriculumStorage };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map