jishushell 0.6.5 → 0.6.18

package/dist/services/files/organize/rules.js

@@ -0,0 +1,286 @@
+/**
+ * Organize rules for the W1.5 file organizer.
+ *
+ * Rules live in `~/.jishushell/files/.organize-rules.json` so they get
+ * backed up alongside user data. If the file is missing we fall back to
+ * the built-in defaults below; if it exists but is malformed we throw at
+ * scan time so the user sees a clear error instead of silently doing
+ * nothing.
+ *
+ * Design constraints:
+ *   - No I/O at import time (constructor-time configuration)
+ *   - validateRules is total: never throws on a *single* bad rule, only
+ *     on whole-file structural errors. Bad rules are returned as
+ *     `{ rule, errors }` so the UI can highlight them inline.
+ *   - move_to template variables are validated lazily (at scan time,
+ *     once per match) — a rule with `{undefined_var}` only errors on
+ *     files that match it, not the whole batch.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { createHash } from "node:crypto";
+import { safeWriteBuffer } from "../../../utils/safe-write.js";
+// ── Built-in defaults ────────────────────────────────
+export const BUILTIN_RULES = [
+    // 1. Photos by EXIF date — most common case
+    {
+        id: "builtin:photos-by-exif",
+        match: {
+            glob: "inbox/**/*.{jpg,jpeg,png,heic}",
+            mime: ["image/*"],
+        },
+        extract: [
+            { from: "exif.DateTimeOriginal", as: "shot", format: "Y-MM" },
+        ],
+        action: {
+            move_to: "photos/{shot}/{basename}",
+            on_collision: "keep-both",
+        },
+        enabled: true,
+    },
+    // 2. Videos by mtime (no EXIF on most videos)
+    {
+        id: "builtin:videos-by-month",
+        match: {
+            glob: "inbox/**/*.{mp4,mov,webm,mkv}",
+            mime: ["video/*"],
+        },
+        extract: [{ from: "mtime", as: "t", format: "Y-MM" }],
+        action: {
+            move_to: "videos/{t}/{basename}",
+            on_collision: "keep-both",
+        },
+        enabled: true,
+    },
+    // 3. Screenshots by day
+    {
+        id: "builtin:screenshots",
+        match: {
+            glob: "**/{Screenshot,屏幕截图,截图}*.{png,jpg}",
+        },
+        extract: [{ from: "mtime", as: "t", format: "Y-MM-DD" }],
+        action: {
+            move_to: "screenshots/{t}/{basename}",
+            on_collision: "keep-both",
+        },
+        enabled: true,
+    },
+    // 4. Invoices (Chinese / English prefix)
+    {
+        id: "builtin:invoices",
+        match: {
+            glob: "inbox/**/{发票,invoice,receipt}*.{pdf,jpg,png}",
+        },
+        extract: [{ from: "mtime", as: "t", format: "Y-MM" }],
+        action: {
+            move_to: "finance/{t}/{basename}",
+            on_collision: "keep-both",
+        },
+        enabled: true,
+    },
+    // 5. Downloads by extension bucket
+    {
+        id: "builtin:downloads-by-ext",
+        match: {
+            glob: "downloads/*",
+        },
+        extract: [{ from: "ext", as: "bucket" }],
+        action: {
+            move_to: "downloads/{bucket}/{basename}",
+            on_collision: "skip",
+        },
+        enabled: false, // off by default — many users prefer flat downloads
+    },
+];
+// ── Validation ───────────────────────────────────────
+const ID_REGEX = /^[a-z0-9][a-z0-9:_-]*$/i;
+export function validateRules(input) {
+    const errors = [];
+    const valid = [];
+    if (!input || typeof input !== "object") {
+        errors.push({ field: "<root>", message: "rules file must be a JSON object" });
+        return { ok: false, errors, valid_rules: [] };
+    }
+    const obj = input;
+    if (obj.version !== 1) {
+        errors.push({ field: "version", message: 'must be the literal number 1' });
+    }
+    if (!Array.isArray(obj.rules)) {
+        errors.push({ field: "rules", message: "must be an array" });
+        return { ok: false, errors, valid_rules: [] };
+    }
+    const seenIds = new Set();
+    obj.rules.forEach((raw, idx) => {
+        const ruleErrors = validateRule(raw, idx, seenIds);
+        if (ruleErrors.length > 0) {
+            errors.push(...ruleErrors);
+        }
+        else {
+            valid.push(raw);
+        }
+    });
+    return {
+        ok: errors.length === 0,
+        errors,
+        valid_rules: valid,
+    };
+}
+function validateRule(raw, index, seenIds) {
+    const errs = [];
+    if (!raw || typeof raw !== "object") {
+        errs.push({ rule_index: index, field: "<rule>", message: "must be an object" });
+        return errs;
+    }
+    const r = raw;
+    // id
+    if (typeof r.id !== "string" || !ID_REGEX.test(r.id)) {
+        errs.push({
+            rule_index: index,
+            rule_id: typeof r.id === "string" ? r.id : undefined,
+            field: "id",
+            message: "must be a slug matching [a-z0-9][a-z0-9:_-]*",
+        });
+    }
+    else if (seenIds.has(r.id)) {
+        errs.push({ rule_index: index, rule_id: r.id, field: "id", message: "duplicate id" });
+    }
+    else {
+        seenIds.add(r.id);
+    }
+    // match
+    if (!r.match || typeof r.match !== "object") {
+        errs.push({ rule_index: index, field: "match", message: "required object" });
+    }
+    else {
+        const m = r.match;
+        const hasGlob = typeof m.glob === "string" && m.glob.length > 0;
+        const hasMime = Array.isArray(m.mime) && m.mime.length > 0;
+        if (!hasGlob && !hasMime) {
+            errs.push({
+                rule_index: index,
+                field: "match",
+                message: "must specify at least one of: glob, mime",
+            });
+        }
+        if (m.glob !== undefined && typeof m.glob !== "string") {
+            errs.push({ rule_index: index, field: "match.glob", message: "must be a string" });
+        }
+        if (m.mime !== undefined && !Array.isArray(m.mime)) {
+            errs.push({ rule_index: index, field: "match.mime", message: "must be an array" });
+        }
+    }
+    // extract (optional)
+    if (r.extract !== undefined) {
+        if (!Array.isArray(r.extract)) {
+            errs.push({ rule_index: index, field: "extract", message: "must be an array if present" });
+        }
+        else {
+            r.extract.forEach((e, eidx) => {
+                if (!e || typeof e !== "object") {
+                    errs.push({
+                        rule_index: index,
+                        field: `extract[${eidx}]`,
+                        message: "must be an object",
+                    });
+                    return;
+                }
+                const ex = e;
+                if (typeof ex.from !== "string" || !ex.from) {
+                    errs.push({
+                        rule_index: index,
+                        field: `extract[${eidx}].from`,
+                        message: "required string",
+                    });
+                }
+                if (typeof ex.as !== "string" || !/^[a-z_][a-z0-9_]*$/i.test(ex.as)) {
+                    errs.push({
+                        rule_index: index,
+                        field: `extract[${eidx}].as`,
+                        message: "required identifier ([a-z_][a-z0-9_]*)",
+                    });
+                }
+            });
+        }
+    }
+    // action
+    if (!r.action || typeof r.action !== "object") {
+        errs.push({ rule_index: index, field: "action", message: "required object" });
+    }
+    else {
+        const a = r.action;
+        if (typeof a.move_to !== "string" || !a.move_to) {
+            errs.push({
+                rule_index: index,
+                field: "action.move_to",
+                message: "required string",
+            });
+        }
+        else if (a.move_to.startsWith("/") || a.move_to.includes("..")) {
+            errs.push({
+                rule_index: index,
+                field: "action.move_to",
+                message: "must be a relative path without ..",
+            });
+        }
+        if (a.on_collision !== undefined &&
+            a.on_collision !== "keep-both" &&
+            a.on_collision !== "overwrite" &&
+            a.on_collision !== "skip") {
+            errs.push({
+                rule_index: index,
+                field: "action.on_collision",
+                message: "must be one of: keep-both | overwrite | skip",
+            });
+        }
+    }
+    return errs;
+}
+// ── Persistence ──────────────────────────────────────
+/**
+ * Reads `<filesRoot>/.organize-rules.json`. If missing, returns built-in
+ * defaults. If malformed, throws — callers should surface the message.
+ */
+export async function readRules(filesRoot) {
+    const file = path.join(filesRoot, ".organize-rules.json");
+    if (!fs.existsSync(file)) {
+        return {
+            rules: BUILTIN_RULES.filter((r) => r.enabled !== false),
+            hash: hashRules(BUILTIN_RULES),
+            source: "builtin",
+        };
+    }
+    const buf = fs.readFileSync(file);
+    let parsed;
+    try {
+        parsed = JSON.parse(buf.toString("utf8"));
+    }
+    catch (e) {
+        throw new Error(`invalid JSON in .organize-rules.json: ${e.message}`);
+    }
+    const result = validateRules(parsed);
+    if (!result.ok) {
+        const summary = result.errors
+            .slice(0, 5)
+            .map((e) => `${e.field}: ${e.message}`)
+            .join("; ");
+        throw new Error(`invalid rules (${result.errors.length} error(s)): ${summary}`);
+    }
+    return {
+        rules: result.valid_rules.filter((r) => r.enabled !== false),
+        hash: hashRules(result.valid_rules),
+        source: "file",
+    };
+}
+export async function writeRules(filesRoot, rules) {
+    const file = path.join(filesRoot, ".organize-rules.json");
+    const payload = { version: 1, rules };
+    const buf = Buffer.from(JSON.stringify(payload, null, 2) + "\n", "utf8");
+    await safeWriteBuffer(file, buf);
+}
+export function hashRules(rules) {
+    // Stable hash based on serialized payload — used to detect rule edits
+    // between scan and apply.
+    const canon = JSON.stringify(rules, Object.keys(rules[0] ?? {}).sort());
+    return createHash("sha256").update(canon).digest("hex").slice(0, 16);
+}
+//# sourceMappingURL=rules.js.map

package/dist/services/files/organize/rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rules.js","sourceRoot":"","sources":["../../../../src/services/files/organize/rules.ts"],"names":[],"mappings":"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"}

package/dist/services/files/organize/scanner.js

@@ -0,0 +1,366 @@
+/**
+ * File scanner for the W1.5 organizer.
+ *
+ * Walks a subtree of the user's files/, matches each file against the
+ * provided rules, and produces a list of move suggestions ready for
+ * the diff UI. No mutations: scanning is side-effect-free other than
+ * stat / EXIF reads.
+ *
+ * Performance budget: 5000 files in < 10 s on a Pi 5. We achieve this
+ * by:
+ *   - skipping symlinks and hidden dirs entirely
+ *   - reading EXIF only for image extensions, only for the first match
+ *     (single 64KB read via exifr's selective parsing)
+ *   - bailing on the first matching rule (rules are evaluated in order)
+ *
+ * The scanner is the only place that owns rule semantics. Both the API
+ * route (W1.5 PR-4) and the W7 Agent organizer call into it identically.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+// exifr is loaded lazily (CJS interop quirks under Node ESM); see readExif.
+import { resolveSafe, validateRelativePath, } from "../../../utils/path-safety.js";
+import { hashRules } from "./rules.js";
+import { randomUUID } from "node:crypto";
+// ── glob ─────────────────────────────────────────────
+/**
+ * Compile a small subset of glob syntax we actually use:
+ *   - `*`   one path segment, no /
+ *   - `**`  any number of segments, including /
+ *   - `?`   one char (no /)
+ *   - `{a,b,c}` alternation (no nesting)
+ *
+ * We deliberately avoid bringing in minimatch/picomatch as a runtime
+ * dep — those libs are 100KB+ and we only need ~5% of their behaviour.
+ */
+export function compileGlob(pattern) {
+    // Expand {a,b,c} groups first. We support a single-level alternation,
+    // matching what the rule examples need.
+    const _expanded = [];
+    let buf = "";
+    let i = 0;
+    while (i < pattern.length) {
+        const c = pattern[i];
+        if (c === "{") {
+            const close = pattern.indexOf("}", i);
+            if (close === -1) {
+                buf += "\\{";
+                i++;
+                continue;
+            }
+            const alts = pattern.slice(i + 1, close).split(",");
+            const altRegex = "(?:" + alts.map(escapeRegexLiteral).join("|") + ")";
+            buf += altRegex;
+            i = close + 1;
+            continue;
+        }
+        if (c === "*") {
+            if (pattern[i + 1] === "*") {
+                // ** — match any chars including /
+                buf += ".*";
+                i += 2;
+                // collapse the slash that immediately follows ** so that
+                // "inbox/**/*.jpg" matches "inbox/x.jpg" too
+                if (pattern[i] === "/")
+                    i++;
+                continue;
+            }
+            buf += "[^/]*";
+            i++;
+            continue;
+        }
+        if (c === "?") {
+            buf += "[^/]";
+            i++;
+            continue;
+        }
+        if (c === ".") {
+            buf += "\\.";
+            i++;
+            continue;
+        }
+        if ("+()^$|\\".includes(c)) {
+            buf += "\\" + c;
+            i++;
+            continue;
+        }
+        buf += c;
+        i++;
+    }
+    return new RegExp("^" + buf + "$", "i");
+}
+function escapeRegexLiteral(s) {
+    return s.replace(/[.+*?^$()[\]{}|\\]/g, "\\$&");
+}
+export function matchGlob(relPath, pattern) {
+    return compileGlob(pattern).test(relPath);
+}
+export function matchMime(mime, patterns) {
+    for (const p of patterns) {
+        if (p.endsWith("/*")) {
+            const prefix = p.slice(0, -1); // keep "image/"
+            if (mime.startsWith(prefix))
+                return true;
+        }
+        else if (p === mime)
+            return true;
+    }
+    return false;
+}
+const IMAGE_EXTS = new Set([
+    ".jpg",
+    ".jpeg",
+    ".png",
+    ".heic",
+    ".heif",
+    ".tiff",
+    ".tif",
+    ".webp",
+]);
+const MIME_BY_EXT = {
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".png": "image/png",
+    ".heic": "image/heic",
+    ".heif": "image/heif",
+    ".tiff": "image/tiff",
+    ".tif": "image/tiff",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".bmp": "image/bmp",
+    ".pdf": "application/pdf",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".webm": "video/webm",
+    ".mkv": "video/x-matroska",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".txt": "text/plain",
+    ".md": "text/markdown",
+    ".json": "application/json",
+};
+function inferMime(ext) {
+    return MIME_BY_EXT[ext.toLowerCase()] ?? "application/octet-stream";
+}
+let _exifrModule = null;
+async function readExifSafe(absPath) {
+    // Only attempt EXIF on known image formats — exifr handles many but
+    // failed parses cost ~1ms each which adds up over thousands of files.
+    const ext = path.extname(absPath).toLowerCase();
+    if (!IMAGE_EXTS.has(ext))
+        return null;
+    try {
+        if (!_exifrModule) {
+            // Dynamic import to keep the test surface light when EXIF is irrelevant
+            _exifrModule = await import("exifr");
+        }
+        const exif = await _exifrModule.parse(absPath, {
+            pick: ["DateTimeOriginal", "CreateDate", "ModifyDate"],
+        });
+        return exif ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+async function extractValue(spec, meta, exifCache) {
+    const from = spec.from;
+    if (from === "mtime") {
+        return formatDate(new Date(meta.mtimeSec * 1000), spec.format ?? "Y-MM-DD");
+    }
+    if (from === "ext") {
+        return meta.ext.replace(/^\./, "");
+    }
+    if (from === "basename")
+        return meta.basename;
+    if (from === "dirname")
+        return meta.dirname;
+    if (from.startsWith("exif.")) {
+        let exif = exifCache.get(meta.absPath);
+        if (exif === undefined) {
+            exif = await readExifSafe(meta.absPath);
+            exifCache.set(meta.absPath, exif);
+        }
+        if (!exif)
+            return null;
+        const key = from.slice(5);
+        let v = exif[key] ?? exif.DateTimeOriginal ?? exif.CreateDate;
+        if (v instanceof Date) {
+            return formatDate(v, spec.format ?? "Y-MM-DD");
+        }
+        if (typeof v === "string" && /^\d{4}/.test(v)) {
+            // exifr sometimes returns "YYYY:MM:DD HH:MM:SS" raw
+            const m = v.match(/^(\d{4})[:-](\d{2})[:-](\d{2})/);
+            if (m) {
+                const d = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+                return formatDate(d, spec.format ?? "Y-MM-DD");
+            }
+        }
+        return null;
+    }
+    return null;
+}
+export function formatDate(d, fmt) {
+    const Y = d.getFullYear().toString();
+    const MM = String(d.getMonth() + 1).padStart(2, "0");
+    const DD = String(d.getDate()).padStart(2, "0");
+    // We support the small set of placeholders that the rules use.
+    return fmt
+        .replace(/Y-MM-DD/g, `${Y}-${MM}-${DD}`)
+        .replace(/Y-MM/g, `${Y}-${MM}`)
+        .replace(/Y/g, Y)
+        .replace(/MM/g, MM)
+        .replace(/DD/g, DD);
+}
+// ── Interpolate ──────────────────────────────────────
+/**
+ * Replace {var} placeholders in a template string. Returns null if any
+ * placeholder is unresolved — the caller should skip or warn the user.
+ */
+export function interpolate(template, vars) {
+    let unresolved = false;
+    const out = template.replace(/\{([a-z_][a-z0-9_]*)\}/gi, (_m, name) => {
+        if (vars[name] === undefined) {
+            unresolved = true;
+            return "";
+        }
+        return vars[name];
+    });
+    return unresolved ? null : out;
+}
+// ── Scan ─────────────────────────────────────────────
+const TRASH_DIR = ".trash";
+const META_FILE = ".organize-rules.json";
+const ORGANIZE_STATE_FILE = ".pending-organize.json";
+export async function scan(filesRoot, rules, rootRel = "", opts = {}) {
+    const maxFiles = opts.maxFiles ?? 10000;
+    const maxFileSize = opts.maxFileSize ?? Number.POSITIVE_INFINITY;
+    // Validate the scan root using the same path-safety guards as Files.
+    if (rootRel !== "")
+        validateRelativePath(rootRel);
+    const rootAbs = rootRel ? resolveSafe(filesRoot, rootRel) : filesRoot;
+    const exifCache = new Map();
+    const suggestions = [];
+    const used = [0]; // boxed counter for recursion
+    async function walk(dirAbs) {
+        if (used[0] >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = fs.readdirSync(dirAbs, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const ent of entries) {
+            if (used[0] >= maxFiles)
+                return;
+            // Skip hidden dirs (.trash, .organize-rules.json, etc.)
+            if (ent.name.startsWith("."))
+                continue;
+            const full = path.join(dirAbs, ent.name);
+            const rel = path.relative(filesRoot, full);
+            if (ent.isSymbolicLink())
+                continue;
+            if (ent.isDirectory()) {
+                await walk(full);
+                continue;
+            }
+            if (!ent.isFile())
+                continue;
+            let stat;
+            try {
+                stat = fs.statSync(full);
+            }
+            catch {
+                continue;
+            }
+            if (stat.size > maxFileSize)
+                continue;
+            used[0]++;
+            const ext = path.extname(rel).toLowerCase();
+            const meta = {
+                relPath: rel,
+                absPath: full,
+                size: stat.size,
+                mtimeSec: Math.floor(stat.mtimeMs / 1000),
+                ext,
+                basename: path.basename(rel),
+                dirname: path.dirname(rel),
+                mime: inferMime(ext),
+            };
+            const matched = await matchAndBuild(meta, rules, exifCache);
+            if (matched)
+                suggestions.push(matched);
+        }
+    }
+    await walk(rootAbs);
+    return {
+        id: randomUUID(),
+        created_at: Math.floor(Date.now() / 1000),
+        status: "pending",
+        source_path: rootRel,
+        rules_hash: hashRules(rules),
+        suggestions,
+    };
+}
+async function matchAndBuild(meta, rules, exifCache) {
+    for (const rule of rules) {
+        if (rule.enabled === false)
+            continue;
+        // Match
+        if (rule.match.glob && !matchGlob(meta.relPath, rule.match.glob))
+            continue;
+        if (rule.match.mime && !matchMime(meta.mime, rule.match.mime))
+            continue;
+        // Extract
+        const vars = {
+            basename: meta.basename,
+            ext: meta.ext.replace(/^\./, ""),
+            dirname: meta.dirname,
+        };
+        let extractFailed = false;
+        for (const ex of rule.extract ?? []) {
+            const v = await extractValue(ex, meta, exifCache);
+            if (v === null) {
+                extractFailed = true;
+                break;
+            }
+            vars[ex.as] = v;
+        }
+        if (extractFailed)
+            continue;
+        // Interpolate target
+        const to = interpolate(rule.action.move_to, vars);
+        if (to === null)
+            continue;
+        if (to === meta.relPath)
+            continue; // no-op
+        // Safety: ensure resolved target stays inside files/, no traversal,
+        // no system directories.
+        try {
+            validateRelativePath(to);
+        }
+        catch {
+            continue;
+        }
+        if (to.startsWith(`${TRASH_DIR}/`) ||
+            to === TRASH_DIR ||
+            to === META_FILE ||
+            to === ORGANIZE_STATE_FILE) {
+            continue;
+        }
+        if (to.startsWith(meta.relPath + "/"))
+            continue; // moving into self
+        return {
+            id: randomUUID(),
+            from: meta.relPath,
+            to,
+            rule_id: rule.id,
+            extracted: vars,
+            selected: true,
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=scanner.js.map