mcp-for-i 0.1.13 → 0.2.0

package/dist/mcp/modules/bulkMembers.js

@@ -0,0 +1,476 @@
+import crypto from "crypto";
+import fs from "fs/promises";
+import path from "path";
+import { Tools } from "../../ibmi/Tools.js";
+import { checkLibrary } from "../policy.js";
+import { clampNumber, enforceWritable, guardLocalPath, json, jsonError } from "../tools.js";
+/**
+ * Bulk source member download/upload between a library's source files and a
+ * local LIB/FILE/MEMBER.ext tree. A manifest in the tree root records each
+ * member's version and SHA-256 at download time, so uploads only send members
+ * edited locally and refuse to overwrite members that changed on the IBM i
+ * since they were downloaded (unless force is true).
+ */
+export const MEMBER_MANIFEST_NAME = ".mcp-for-i-members.json";
+const MANIFEST_FORMAT = "mcp-for-i-members";
+const DEFAULT_MAX_MEMBERS = 500;
+const HARD_MAX_MEMBERS = 5000;
+const ANNOTATIONS_DOWNLOAD = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+const ANNOTATIONS_UPLOAD = { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false };
+export const bulkMembersModule = {
+    tools: [
+        {
+            name: "ibmi.members.downloadAll",
+            description: "Download every member of a source file (or of all source files in a library) to a local LIB/FILE/MEMBER.ext tree. " +
+                "The extension is the lowercased member type. Writes a manifest (" + MEMBER_MANIFEST_NAME + ") with each member's version " +
+                "and SHA-256 so ibmi.members.uploadChanged can detect conflicts. Local files edited since the last download are kept unless overwrite is true.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    connectionName: { type: "string" },
+                    localPath: { type: "string", description: "Local root directory of the LIB/FILE/MEMBER.ext tree." },
+                    library: { type: "string" },
+                    sourceFile: { type: "string", description: "One source file. Omit to download all source files in the library." },
+                    sourceFiles: { type: "array", items: { type: "string" }, description: "Several source files." },
+                    memberPrefix: { type: "string" },
+                    sourceTypes: { type: "array", items: { type: "string" } },
+                    maxMembers: { type: "number", default: DEFAULT_MAX_MEMBERS, description: `Member cap (1-${HARD_MAX_MEMBERS}).` },
+                    overwrite: { type: "boolean", default: false, description: "Replace local files that were edited since the last download." }
+                },
+                required: ["localPath", "library"],
+                additionalProperties: false
+            },
+            annotations: ANNOTATIONS_DOWNLOAD
+        },
+        {
+            name: "ibmi.members.uploadChanged",
+            description: "Upload members from a local LIB/FILE/MEMBER.ext tree (as written by ibmi.members.downloadAll) that changed locally since download. " +
+                "Unchanged files are skipped without contacting the IBM i. A member that changed on the IBM i since download (or has no manifest entry " +
+                "and differs) is refused as a conflict unless force is true. Missing members are created with SRCTYPE from the manifest or file extension.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    connectionName: { type: "string" },
+                    localPath: { type: "string", description: "Local root directory of the LIB/FILE/MEMBER.ext tree." },
+                    library: { type: "string", description: "Only upload members of this library." },
+                    sourceFile: { type: "string", description: "Only upload members of this source file." },
+                    members: { type: "array", items: { type: "string" }, description: "Only upload these member names." },
+                    force: { type: "boolean", default: false, description: "Overwrite members that changed on the IBM i since download." },
+                    createMissing: { type: "boolean", default: true },
+                    dryRun: { type: "boolean", default: false },
+                    maxMembers: { type: "number", default: DEFAULT_MAX_MEMBERS, description: `Cap on members uploaded (1-${HARD_MAX_MEMBERS}).` },
+                    approve: { type: "boolean" }
+                },
+                required: ["localPath"],
+                additionalProperties: false
+            },
+            annotations: ANNOTATIONS_UPLOAD
+        }
+    ],
+    async handle(ctx, name, args) {
+        switch (name) {
+            case "ibmi.members.downloadAll":
+                return downloadAll(ctx, args || {});
+            case "ibmi.members.uploadChanged":
+                return uploadChanged(ctx, args || {});
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    }
+};
+function qsysName(conn, value, label) {
+    const raw = String(value ?? "").trim().toUpperCase();
+    if (!raw)
+        throw new Error(`${label} is required`);
+    if (!conn.validQsysName(raw))
+        throw new Error(`Invalid ${label}: ${value}`);
+    return raw;
+}
+export function extensionForSourceType(sourceType) {
+    const ext = String(sourceType ?? "").trim().toLowerCase();
+    return /^[a-z0-9#@$_]{1,10}$/.test(ext) ? ext : "mbr";
+}
+export function sourceTypeForExtension(ext) {
+    const type = String(ext || "").trim().toUpperCase();
+    if (!type || type === "MBR")
+        return undefined;
+    return /^[A-Z0-9#@$_]{1,10}$/.test(type) ? type : undefined;
+}
+function normalizeContent(content) {
+    return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+function sha256(content) {
+    return crypto.createHash("sha256").update(content, "utf8").digest("hex");
+}
+function memberKey(library, sourceFile, member) {
+    return `${library}/${sourceFile}/${member}`;
+}
+function emptyManifest(connectionName) {
+    return { format: MANIFEST_FORMAT, version: 1, connectionName, updatedAt: new Date().toISOString(), members: {} };
+}
+async function readManifest(ctx, root) {
+    const manifestPath = await guardLocalPath(ctx, path.join(root, MEMBER_MANIFEST_NAME), "read");
+    let text;
+    try {
+        text = await fs.readFile(manifestPath, "utf8");
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            return { manifest: emptyManifest(), existed: false };
+        throw err;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`Member manifest ${manifestPath} is not valid JSON`);
+    }
+    if (parsed?.format !== MANIFEST_FORMAT || typeof parsed?.members !== "object" || parsed.members === null) {
+        throw new Error(`Member manifest ${manifestPath} has an unknown format`);
+    }
+    return { manifest: parsed, existed: true };
+}
+async function writeManifest(ctx, root, manifest) {
+    const manifestPath = await guardLocalPath(ctx, path.join(root, MEMBER_MANIFEST_NAME), "write");
+    manifest.updatedAt = new Date().toISOString();
+    const sorted = {};
+    for (const key of Object.keys(manifest.members).sort())
+        sorted[key] = manifest.members[key];
+    manifest.members = sorted;
+    await fs.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+    return manifestPath;
+}
+async function readLocalText(filePath) {
+    try {
+        return await fs.readFile(filePath, "utf8");
+    }
+    catch (err) {
+        if (err?.code === "ENOENT")
+            return undefined;
+        throw err;
+    }
+}
+async function listSourceFiles(conn, library) {
+    const rows = await conn.runSQL(`select SYSTEM_TABLE_NAME from QSYS2.SYSTABLES where SYSTEM_TABLE_SCHEMA=${Tools.sqlString(library)} ` +
+        `and FILE_TYPE='S' order by SYSTEM_TABLE_NAME`);
+    return rows
+        .map((row) => String(row?.SYSTEM_TABLE_NAME || "").trim().toUpperCase())
+        .filter((name) => name && conn.validQsysName(name));
+}
+function entryFromSnapshot(snapshot, sourceType, text, relPath) {
+    return {
+        library: snapshot.identity.library,
+        sourceFile: snapshot.identity.sourceFile,
+        member: snapshot.identity.member,
+        sourceType,
+        ...(text ? { text } : {}),
+        path: relPath,
+        sha256: snapshot.sha256,
+        version: snapshot.version,
+        ...(snapshot.metadata?.lastChanged ? { lastChanged: snapshot.metadata.lastChanged } : {}),
+        syncedAt: new Date().toISOString()
+    };
+}
+async function downloadAll(ctx, args) {
+    const conn = await ctx.ensureActive(args.connectionName);
+    const library = qsysName(conn, args.library, "library");
+    const root = await guardLocalPath(ctx, args.localPath, "write");
+    const maxMembers = clampNumber(args.maxMembers, DEFAULT_MAX_MEMBERS, 1, HARD_MAX_MEMBERS);
+    const overwrite = Boolean(args.overwrite);
+    let sourceFiles;
+    if (args.sourceFile)
+        sourceFiles = [qsysName(conn, args.sourceFile, "sourceFile")];
+    else if (Array.isArray(args.sourceFiles) && args.sourceFiles.length > 0) {
+        sourceFiles = Array.from(new Set(args.sourceFiles.map((value) => qsysName(conn, value, "sourceFile"))));
+    }
+    else
+        sourceFiles = await listSourceFiles(conn, library);
+    // Collect the member list first so the cap applies across all files.
+    const members = [];
+    let truncated = false;
+    for (const sourceFile of sourceFiles) {
+        let cursor;
+        do {
+            const page = await conn.content.getMemberListPage({
+                library,
+                sourceFile,
+                memberPrefix: args.memberPrefix,
+                sourceTypes: args.sourceTypes,
+                limit: 500,
+                cursor
+            });
+            for (const item of page.items || []) {
+                if (members.length >= maxMembers) {
+                    truncated = true;
+                    break;
+                }
+                members.push({ sourceFile, name: String(item.name).toUpperCase(), sourceType: String(item.extension || ""), text: String(item.text || "") });
+            }
+            cursor = !truncated && page.hasMore ? page.nextCursor : undefined;
+        } while (cursor);
+        if (truncated)
+            break;
+    }
+    const { manifest } = await readManifest(ctx, root);
+    manifest.connectionName = conn.currentConnectionName || args.connectionName || manifest.connectionName;
+    const downloaded = [];
+    const unchanged = [];
+    const skipped = [];
+    const failed = [];
+    for (const item of members) {
+        const key = memberKey(library, item.sourceFile, item.name);
+        const relPath = `${library}/${item.sourceFile}/${item.name}.${extensionForSourceType(item.sourceType)}`;
+        try {
+            const target = await guardLocalPath(ctx, path.join(root, ...relPath.split("/")), "write");
+            const snapshot = await conn.content.getMemberSnapshot(library, item.sourceFile, item.name, true);
+            const existing = await readLocalText(target);
+            const prior = manifest.members[key];
+            if (existing !== undefined) {
+                const localSha = sha256(normalizeContent(existing));
+                if (localSha === snapshot.sha256) {
+                    manifest.members[key] = entryFromSnapshot(snapshot, item.sourceType, item.text, relPath);
+                    unchanged.push(relPath);
+                    continue;
+                }
+                const editedLocally = prior ? localSha !== prior.sha256 : true;
+                if (editedLocally && !overwrite) {
+                    skipped.push({ path: relPath, reason: prior ? "local file edited since last download" : "local file exists and is not in the manifest" });
+                    continue;
+                }
+            }
+            await fs.mkdir(path.dirname(target), { recursive: true });
+            await fs.writeFile(target, snapshot.content, "utf8");
+            manifest.members[key] = entryFromSnapshot(snapshot, item.sourceType, item.text, relPath);
+            downloaded.push(relPath);
+        }
+        catch (err) {
+            failed.push({ member: key, message: err?.message || String(err) });
+        }
+    }
+    const manifestPath = await writeManifest(ctx, root, manifest);
+    const payload = {
+        ok: failed.length === 0,
+        localRoot: root,
+        library,
+        sourceFiles,
+        manifestPath,
+        truncated,
+        ...(truncated ? { hint: `Stopped at maxMembers=${maxMembers}; narrow with sourceFile/memberPrefix or raise maxMembers.` } : {}),
+        summary: {
+            members: members.length,
+            downloaded: downloaded.length,
+            unchanged: unchanged.length,
+            skipped: skipped.length,
+            failed: failed.length
+        },
+        downloaded,
+        unchanged,
+        skipped,
+        failed
+    };
+    if (failed.length > 0)
+        return jsonError(`members.downloadAll finished with ${failed.length} failed member(s)`, payload);
+    return json(payload);
+}
+async function walkMemberTree(conn, root, skipped) {
+    const out = [];
+    const dirents = async (dir) => (await fs.readdir(dir, { withFileTypes: true })).filter(entry => !entry.name.startsWith("."));
+    for (const libEntry of await dirents(root)) {
+        if (!libEntry.isDirectory())
+            continue;
+        const library = libEntry.name.toUpperCase();
+        if (!conn.validQsysName(library)) {
+            skipped.push({ path: libEntry.name, reason: "directory name is not a valid library name" });
+            continue;
+        }
+        for (const fileEntry of await dirents(path.join(root, libEntry.name))) {
+            if (!fileEntry.isDirectory())
+                continue;
+            const sourceFile = fileEntry.name.toUpperCase();
+            const fileDir = `${libEntry.name}/${fileEntry.name}`;
+            if (!conn.validQsysName(sourceFile)) {
+                skipped.push({ path: fileDir, reason: "directory name is not a valid source file name" });
+                continue;
+            }
+            for (const memberEntry of await dirents(path.join(root, libEntry.name, fileEntry.name))) {
+                if (!memberEntry.isFile())
+                    continue;
+                const relPath = `${fileDir}/${memberEntry.name}`;
+                const dot = memberEntry.name.lastIndexOf(".");
+                const member = (dot > 0 ? memberEntry.name.substring(0, dot) : memberEntry.name).toUpperCase();
+                const ext = dot > 0 ? memberEntry.name.substring(dot + 1) : "";
+                if (!conn.validQsysName(member)) {
+                    skipped.push({ path: relPath, reason: "file name is not a valid member name" });
+                    continue;
+                }
+                out.push({ library, sourceFile, member, ext, relPath, fullPath: path.join(root, libEntry.name, fileEntry.name, memberEntry.name) });
+            }
+        }
+    }
+    return out.sort((a, b) => a.relPath.localeCompare(b.relPath));
+}
+async function uploadChanged(ctx, args) {
+    const conn = await ctx.ensureActive(args.connectionName);
+    const root = await guardLocalPath(ctx, args.localPath, "read");
+    const dryRun = Boolean(args.dryRun);
+    const force = Boolean(args.force);
+    const createMissing = args.createMissing !== false;
+    const maxMembers = clampNumber(args.maxMembers, DEFAULT_MAX_MEMBERS, 1, HARD_MAX_MEMBERS);
+    const libraryFilter = args.library ? qsysName(conn, args.library, "library") : undefined;
+    const fileFilter = args.sourceFile ? qsysName(conn, args.sourceFile, "sourceFile") : undefined;
+    const memberFilter = Array.isArray(args.members) && args.members.length > 0
+        ? new Set(args.members.map((value) => qsysName(conn, value, "member")))
+        : undefined;
+    if (!dryRun)
+        await enforceWritable(ctx, conn, "qsys.write", args);
+    const { manifest, existed: manifestExisted } = await readManifest(ctx, root);
+    const skipped = [];
+    const candidates = (await walkMemberTree(conn, root, skipped)).filter(item => (!libraryFilter || item.library === libraryFilter) &&
+        (!fileFilter || item.sourceFile === fileFilter) &&
+        (!memberFilter || memberFilter.has(item.member)));
+    const policy = ctx.getPolicy(args.connectionName);
+    const deniedLibraries = new Map();
+    for (const library of new Set(candidates.map(item => item.library))) {
+        const reason = checkLibrary(policy, library);
+        if (reason)
+            deniedLibraries.set(library, reason);
+    }
+    const unchanged = [];
+    const inSync = [];
+    const conflicts = [];
+    const planned = [];
+    const uploaded = [];
+    const failed = [];
+    let truncated = false;
+    for (const item of candidates) {
+        const key = memberKey(item.library, item.sourceFile, item.member);
+        const denied = deniedLibraries.get(item.library);
+        if (denied) {
+            skipped.push({ path: item.relPath, reason: `blocked by policy: ${denied}` });
+            continue;
+        }
+        try {
+            const localFile = await guardLocalPath(ctx, item.fullPath, "read");
+            const content = normalizeContent(await fs.readFile(localFile, "utf8"));
+            const localSha = sha256(content);
+            const entry = manifest.members[key];
+            if (entry && entry.sha256 === localSha) {
+                unchanged.push(item.relPath);
+                continue;
+            }
+            const metadata = await conn.content.getMemberMetadata(item.library, item.sourceFile, item.member);
+            let action;
+            const sourceType = entry?.sourceType || sourceTypeForExtension(item.ext);
+            if (!metadata) {
+                if (!createMissing) {
+                    skipped.push({ path: item.relPath, reason: "member does not exist on the IBM i (createMissing is false)" });
+                    continue;
+                }
+                action = "create";
+            }
+            else {
+                action = "update";
+                // Same last-change timestamp as at download means the remote member
+                // is unchanged; otherwise compare content hashes.
+                const remoteUnchanged = Boolean(entry?.lastChanged && metadata.lastChanged && entry.lastChanged === metadata.lastChanged);
+                if (!remoteUnchanged) {
+                    const snapshot = await conn.content.getMemberSnapshot(item.library, item.sourceFile, item.member, true);
+                    if (snapshot.sha256 === localSha) {
+                        manifest.members[key] = entryFromSnapshot(snapshot, metadata.extension || sourceType || "", metadata.text, item.relPath);
+                        inSync.push(item.relPath);
+                        continue;
+                    }
+                    const remoteChanged = entry ? snapshot.sha256 !== entry.sha256 : true;
+                    if (remoteChanged && !force) {
+                        conflicts.push({
+                            path: item.relPath,
+                            reason: entry ? "member changed on the IBM i since download" : "member exists on the IBM i but is not in the manifest",
+                            ...(entry ? { expectedVersion: entry.version } : {}),
+                            actualVersion: snapshot.version
+                        });
+                        continue;
+                    }
+                }
+            }
+            if (planned.length >= maxMembers) {
+                truncated = true;
+                break;
+            }
+            planned.push({ path: item.relPath, action, ...(action === "create" ? { sourceType: sourceType || "*NONE" } : {}) });
+            if (dryRun)
+                continue;
+            if (action === "create") {
+                await conn.content.createMember(item.library, item.sourceFile, item.member, sourceType);
+            }
+            try {
+                await conn.content.uploadMemberContent(item.library, item.sourceFile, item.member, content);
+            }
+            finally {
+                conn.content.invalidateMemberSnapshot?.(item.library, item.sourceFile, item.member);
+            }
+            let version;
+            try {
+                const after = await conn.content.getMemberSnapshot(item.library, item.sourceFile, item.member, true);
+                manifest.members[key] = entryFromSnapshot(after, metadata?.extension || sourceType || "", metadata?.text || entry?.text, item.relPath);
+                version = after.version;
+            }
+            catch {
+                // The upload worked; record the local hash so the next run treats it as unchanged.
+                manifest.members[key] = {
+                    library: item.library,
+                    sourceFile: item.sourceFile,
+                    member: item.member,
+                    sourceType: metadata?.extension || sourceType || "",
+                    path: item.relPath,
+                    sha256: localSha,
+                    version: `unknown:${localSha.slice(0, 16)}`,
+                    syncedAt: new Date().toISOString()
+                };
+            }
+            uploaded.push({ path: item.relPath, action, ...(version ? { version } : {}) });
+        }
+        catch (err) {
+            failed.push({ path: item.relPath, message: err?.message || String(err) });
+        }
+    }
+    let manifestPath;
+    if (!dryRun && (uploaded.length > 0 || inSync.length > 0)) {
+        manifest.connectionName = conn.currentConnectionName || args.connectionName || manifest.connectionName;
+        manifestPath = await writeManifest(ctx, root, manifest);
+    }
+    const payload = {
+        ok: failed.length === 0 && conflicts.length === 0,
+        localRoot: root,
+        dryRun,
+        force,
+        manifestFound: manifestExisted,
+        ...(manifestPath ? { manifestPath } : {}),
+        truncated,
+        summary: {
+            candidates: candidates.length,
+            planned: planned.length,
+            uploaded: uploaded.length,
+            unchanged: unchanged.length,
+            alreadyInSync: inSync.length,
+            conflicts: conflicts.length,
+            skipped: skipped.length,
+            failed: failed.length
+        },
+        planned,
+        uploaded,
+        conflicts,
+        skipped,
+        failed,
+        unchanged,
+        alreadyInSync: inSync
+    };
+    if (failed.length > 0 || conflicts.length > 0) {
+        const parts = [
+            failed.length > 0 ? `${failed.length} failed` : "",
+            conflicts.length > 0 ? `${conflicts.length} conflict(s); re-download or pass force:true to overwrite` : ""
+        ].filter(Boolean);
+        return jsonError(`members.uploadChanged: ${parts.join(", ")}`, payload);
+    }
+    return json(payload);
+}

package/dist/mcp/modules/changedLines.js

@@ -0,0 +1,189 @@
+import { makeAliasName } from "../../ibmi/sourceDates.js";
+import { clampInteger, json, requireQsysName } from "../tools.js";
+const DEFAULT_MAX_LINES = 500;
+const HARD_MAX_LINES = 5000;
+const DEFAULT_MAX_MEMBERS = 50;
+const HARD_MAX_MEMBERS = 500;
+/**
+ * SRCDAT holds a two-digit year (YYMMDD). IBM i uses the 1940-2039 window
+ * for two-digit years: 40-99 are 19xx and 00-39 are 20xx. A zero or blank
+ * SRCDAT means the line has no date.
+ */
+export function srcdatToFullDate(value) {
+    const digits = Number(value);
+    if (!Number.isFinite(digits) || digits <= 0)
+        return 0;
+    return digits >= 400000 ? 19000000 + digits : 20000000 + digits;
+}
+export function fullDateToIso(value) {
+    if (!value)
+        return null;
+    const text = String(value).padStart(8, "0");
+    return `${text.slice(0, 4)}-${text.slice(4, 6)}-${text.slice(6, 8)}`;
+}
+/** Accepts YYYY-MM-DD, YYYYMMDD or a six-digit SRCDAT-style YYMMDD. Returns YYYYMMDD as a number. */
+export function parseDateArgument(value, label) {
+    const raw = String(value ?? "").trim();
+    let year;
+    let month;
+    let day;
+    let match;
+    if ((match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(raw)) || (match = /^(\d{4})(\d{2})(\d{2})$/.exec(raw))) {
+        [year, month, day] = [Number(match[1]), Number(match[2]), Number(match[3])];
+    }
+    else if ((match = /^(\d{2})(\d{2})(\d{2})$/.exec(raw))) {
+        const full = srcdatToFullDate(raw);
+        [year, month, day] = [Math.floor(full / 10000), Number(match[2]), Number(match[3])];
+    }
+    else {
+        throw new Error(`Invalid ${label}: ${raw || "(empty)"}. Use YYYY-MM-DD.`);
+    }
+    const date = new Date(Date.UTC(year, month - 1, day));
+    if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
+        throw new Error(`Invalid ${label}: ${raw} is not a real date`);
+    }
+    return year * 10000 + month * 100 + day;
+}
+function todayFullDate(now = new Date()) {
+    return now.getFullYear() * 10000 + (now.getMonth() + 1) * 100 + now.getDate();
+}
+/** A member name, or a generic name using `*` (for example ORD* or *ALL). */
+function memberPattern(value) {
+    const raw = String(value ?? "").trim().toUpperCase();
+    if (!raw || raw === "*ALL" || raw === "*")
+        return { generic: true, like: "%" };
+    if (!raw.includes("*"))
+        return { generic: false, name: raw };
+    if (!/^[A-Z0-9#@$._*]{1,10}$/.test(raw))
+        throw new Error(`Invalid member filter: ${value}`);
+    const like = raw.replace(/_/g, "\\_").replace(/\*/g, "%");
+    return { generic: true, like };
+}
+function quoteSql(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/** Source member date expression, matching how source dates are read elsewhere (blank SRCDAT is 0). */
+const SRCDAT_EXPRESSION = "case when locate('40', hex(M.SRCDAT)) > 0 then 0 when M.SRCDAT = 0 then 0 " +
+    "when M.SRCDAT >= 400000 then 19000000 + M.SRCDAT else 20000000 + M.SRCDAT end";
+export function buildChangedLinesSql(library, sourceFile, member, from, to, limit) {
+    const alias = `QTEMP."${makeAliasName(`${library}/${sourceFile}/${member}`)}"`;
+    return (`create or replace alias ${alias} for "${library}"."${sourceFile}"("${member}");\n` +
+        "select X.LINE_NUMBER, X.SRCSEQ, X.FULL_DATE, X.SRCDTA from (" +
+        `select row_number() over (order by rrn(M)) as LINE_NUMBER, M.SRCSEQ, ${SRCDAT_EXPRESSION} as FULL_DATE, M.SRCDTA ` +
+        `from ${alias} as M) as X where X.FULL_DATE between ${from} and ${to} ` +
+        `order by X.LINE_NUMBER fetch first ${limit} rows only`);
+}
+async function changedLines(ctx, args) {
+    const conn = await ctx.ensureActive(args?.connectionName);
+    const library = requireQsysName(conn, args?.library, "library");
+    const sourceFile = requireQsysName(conn, args?.sourceFile, "sourceFile");
+    const pattern = memberPattern(args?.member);
+    const from = parseDateArgument(args?.from, "from");
+    const to = args?.to === undefined || args?.to === null || args?.to === "" ? todayFullDate() : parseDateArgument(args.to, "to");
+    if (to < from)
+        throw new Error("to must not be before from");
+    const maxLines = clampInteger(args?.maxLines, 1, HARD_MAX_LINES, DEFAULT_MAX_LINES);
+    const maxMembers = clampInteger(args?.maxMembers, 1, HARD_MAX_MEMBERS, DEFAULT_MAX_MEMBERS);
+    let members;
+    let membersTruncated = false;
+    if (pattern.generic) {
+        const memberType = args?.memberType ? String(args.memberType).trim().toUpperCase() : "";
+        if (memberType && !/^[A-Z0-9]{1,10}$/.test(memberType))
+            throw new Error(`Invalid memberType: ${args.memberType}`);
+        const rows = await conn.runSQL("select SYSTEM_TABLE_MEMBER from QSYS2.SYSPARTITIONSTAT " +
+            `where SYSTEM_TABLE_SCHEMA = ${quoteSql(library)} and SYSTEM_TABLE_NAME = ${quoteSql(sourceFile)} ` +
+            (pattern.like !== "%" ? `and SYSTEM_TABLE_MEMBER like ${quoteSql(pattern.like)} escape '\\' ` : "") +
+            (memberType ? `and SOURCE_TYPE = ${quoteSql(memberType)} ` : "") +
+            `order by SYSTEM_TABLE_MEMBER fetch first ${maxMembers + 1} rows only`);
+        members = rows.map((row) => String(row.SYSTEM_TABLE_MEMBER ?? "").trim()).filter(Boolean);
+        membersTruncated = members.length > maxMembers;
+        members = members.slice(0, maxMembers).filter(name => conn.validQsysName(name));
+    }
+    else {
+        members = [requireQsysName(conn, pattern.name, "member")];
+    }
+    const hits = [];
+    const errors = [];
+    let linesTruncated = false;
+    let membersSearched = 0;
+    for (const member of members) {
+        const remaining = maxLines - hits.length;
+        if (remaining <= 0) {
+            linesTruncated = true;
+            break;
+        }
+        let rows;
+        try {
+            rows = await conn.runSQL(buildChangedLinesSql(library, sourceFile, member, from, to, remaining + 1));
+        }
+        catch (error) {
+            if (!pattern.generic)
+                throw error;
+            errors.push({ member, error: error?.message || String(error) });
+            continue;
+        }
+        membersSearched += 1;
+        if (rows.length > remaining)
+            linesTruncated = true;
+        for (const row of rows.slice(0, remaining)) {
+            const sequence = Number(row.SRCSEQ);
+            hits.push({
+                member,
+                line: Number(row.LINE_NUMBER),
+                sequence: Number.isFinite(sequence) ? sequence : null,
+                date: fullDateToIso(Number(row.FULL_DATE)),
+                text: String(row.SRCDTA ?? "").trimEnd()
+            });
+        }
+    }
+    const truncated = linesTruncated || membersTruncated;
+    const reasons = [
+        ...(linesTruncated ? [`Stopped at maxLines=${maxLines}.`] : []),
+        ...(membersTruncated ? [`More than maxMembers=${maxMembers} members match; only the first ${maxMembers} were searched.`] : [])
+    ];
+    return json({
+        library,
+        sourceFile,
+        member: pattern.generic ? String(args?.member || "*ALL").toUpperCase() : members[0],
+        from: fullDateToIso(from),
+        to: fullDateToIso(to),
+        centuryRule: "SRCDAT years 40-99 are 1940-1999 and 00-39 are 2000-2039; lines with no date are never returned.",
+        membersSearched,
+        hits,
+        returned: hits.length,
+        truncated,
+        ...(truncated ? { truncatedReason: reasons.join(" ") } : {}),
+        ...(errors.length ? { errors } : {})
+    });
+}
+export const changedLinesModule = {
+    tools: [
+        {
+            name: "ibmi.search.changedLines",
+            description: "Find source lines whose change date (SRCDAT) falls in a date range, in one member or in the members of a source file " +
+                "matching a generic name (ORD*, *ALL). Returns member, line number, sequence, date and text. Read-only; results are capped.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    connectionName: { type: "string", description: "Saved IBM i connection name." },
+                    library: { type: "string" },
+                    sourceFile: { type: "string" },
+                    member: { type: "string", description: "Member name, or a generic name with * (for example ORD*). Default *ALL." },
+                    memberType: { type: "string", description: "Only search members of this source type (generic member only)." },
+                    from: { type: "string", description: "Start date, inclusive (YYYY-MM-DD)." },
+                    to: { type: "string", description: "End date, inclusive (YYYY-MM-DD). Default today." },
+                    maxLines: { type: "number", description: `Maximum lines returned (default ${DEFAULT_MAX_LINES}, max ${HARD_MAX_LINES}).` },
+                    maxMembers: { type: "number", description: `Maximum members searched (default ${DEFAULT_MAX_MEMBERS}, max ${HARD_MAX_MEMBERS}).` }
+                },
+                required: ["library", "sourceFile", "from"],
+                additionalProperties: false
+            },
+            annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+        }
+    ],
+    handle: async (ctx, name, args) => {
+        if (name === "ibmi.search.changedLines")
+            return changedLines(ctx, args);
+        throw new Error(`Unknown tool: ${name}`);
+    }
+};