@aipper/aiws 0.0.29 → 0.0.31

package/src/aiws-package.js

@@ -1,15 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { readText } from "./fs.js";
-
-/**
- * @returns {Promise<{ rootDir: string, version: string }>}
- */
-export async function loadAiwsPackage() {
-  const here = fileURLToPath(import.meta.url);
-  const rootDir = path.resolve(path.dirname(here), "..");
-  const pkg = JSON.parse(await readText(path.join(rootDir, "package.json")));
-  const version = String(pkg.version || "").trim() || "0.0.0";
-  return { rootDir, version };
-}
-

package/src/backup.js

@@ -1,149 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { ensureDir, pathExists } from "./fs.js";
-import { joinRel, normalizeRel } from "./path-utils.js";
-import { UserError } from "./errors.js";
-
-/**
- * @param {Date} d
- */
-export function formatBackupTimestamp(d) {
-  return d.toISOString().replace(/\.\d{3}Z$/, "Z").replaceAll(":", "-");
-}
-
-export class BackupSession {
-  /**
-   * @param {{ workspaceRoot: string, operation: "init" | "update" }} options
-   */
-  constructor(options) {
-    this.workspaceRoot = options.workspaceRoot;
-    this.operation = options.operation;
-    this.timestamp = formatBackupTimestamp(new Date());
-    this.backupRoot = path.join(this.workspaceRoot, ".aiws", "backups", this.timestamp);
-    /** @type {Map<string, { existed: boolean, mode: number | null }>} */
-    this.files = new Map();
-    this._prepared = false;
-  }
-
-  async _prepare() {
-    if (this._prepared) return;
-    await ensureDir(this.backupRoot);
-    this._prepared = true;
-  }
-
-  /**
-   * Record a file before modification.
-   *
-   * For update: record both existing and missing files (for rollback deletions).
-   * For init: typically record only existing files that will be modified.
-   *
-   * @param {string} relPosix
-   * @param {{ recordMissing?: boolean }=} options
-   */
-  async recordFile(relPosix, options) {
-    const rel = normalizeRel(relPosix);
-    if (this.files.has(rel)) return;
-
-    const abs = joinRel(this.workspaceRoot, rel);
-    const exists = await pathExists(abs);
-    if (!exists) {
-      if (options?.recordMissing) {
-        this.files.set(rel, { existed: false, mode: null });
-      }
-      return;
-    }
-
-    const st = await fs.stat(abs);
-    if (!st.isFile()) {
-      if (options?.recordMissing) this.files.set(rel, { existed: false, mode: null });
-      return;
-    }
-
-    await this._prepare();
-    const dest = joinRel(this.backupRoot, rel);
-    await ensureDir(path.dirname(dest));
-    await fs.copyFile(abs, dest);
-    try {
-      await fs.chmod(dest, st.mode & 0o777);
-    } catch {
-      // ignore chmod errors
-    }
-
-    this.files.set(rel, { existed: true, mode: st.mode & 0o777 });
-  }
-
-  /**
-   * @param {{ extra?: any }=} options
-   */
-  async finalize(options) {
-    if (!this._prepared && this.files.size === 0) return null;
-    await this._prepare();
-    const meta = {
-      operation: this.operation,
-      timestamp: this.timestamp,
-      created_at: new Date().toISOString(),
-      files: Array.from(this.files.entries()).map(([p, v]) => ({ path: p, existed: v.existed, mode: v.mode })),
-      extra: options?.extra ?? null,
-    };
-    await fs.writeFile(path.join(this.backupRoot, "backup.json"), JSON.stringify(meta, null, 2) + "\n", "utf8");
-    return this.backupRoot;
-  }
-}
-
-/**
- * @param {string} workspaceRoot
- * @param {string} stamp
- * @returns {Promise<string>} backup root dir
- */
-export async function resolveBackupRoot(workspaceRoot, stamp) {
-  const backupsRoot = path.join(workspaceRoot, ".aiws", "backups");
-  if (stamp === "latest") {
-    if (!(await pathExists(backupsRoot))) throw new UserError("No backups found.");
-    const entries = await fs.readdir(backupsRoot, { withFileTypes: true });
-    const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
-    const latest = dirs[dirs.length - 1];
-    if (!latest) throw new UserError("No backups found.");
-    return path.join(backupsRoot, latest);
-  }
-
-  const target = path.join(backupsRoot, stamp);
-  if (!(await pathExists(target))) {
-    throw new UserError(`Backup not found: ${stamp}`, { details: `Missing: ${target}` });
-  }
-  return target;
-}
-
-/**
- * @param {string} workspaceRoot
- * @param {string} backupRoot
- */
-export async function rollbackFromBackup(workspaceRoot, backupRoot) {
-  const metaPath = path.join(backupRoot, "backup.json");
-  if (!(await pathExists(metaPath))) {
-    throw new UserError("backup.json not found; cannot rollback safely.", { details: `Missing: ${metaPath}` });
-  }
-  const meta = JSON.parse(await fs.readFile(metaPath, "utf8"));
-  const files = Array.isArray(meta.files) ? meta.files : [];
-  for (const f of files) {
-    const rel = normalizeRel(String(f.path || ""));
-    if (!rel) continue;
-    const dest = joinRel(workspaceRoot, rel);
-    if (f.existed) {
-      const src = joinRel(backupRoot, rel);
-      await ensureDir(path.dirname(dest));
-      await fs.copyFile(src, dest);
-      if (typeof f.mode === "number") {
-        try {
-          await fs.chmod(dest, f.mode);
-        } catch {
-          // ignore chmod errors
-        }
-      }
-    } else {
-      if (await pathExists(dest)) {
-        await fs.rm(dest, { force: true });
-      }
-    }
-  }
-}
-