@guru-ai-product/ai-product-kit 0.1.251112172507

package/skills/aipk_design/auto_panel_splitter/scripts/panel_asset_mapper.js

@@ -0,0 +1,445 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const fsp = require("node:fs/promises");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const { parseArgs } = require("node:util");
+const sharp = require("sharp");
+
+const IMAGE_EXTS = new Set([".png", ".jpg", ".jpeg", ".webp"]);
+const FORMAT_MAP = new Map([
+  [".png", "png"],
+  [".jpg", "jpeg"],
+  [".jpeg", "jpeg"],
+  [".webp", "webp"],
+]);
+
+class PanelRow {
+  constructor({ originalName, originalPath, fileSlug, version, panelTitle, notes }) {
+    this.originalName = originalName;
+    this.originalPath = originalPath;
+    this.fileSlug = fileSlug;
+    this.version = version;
+    this.panelTitle = panelTitle;
+    this.notes = notes;
+  }
+
+  finalStem() {
+    return this.version ? `${this.fileSlug}-${this.version}` : this.fileSlug;
+  }
+
+  extension() {
+    return path.extname(this.originalName).toLowerCase();
+  }
+}
+
+class CopyResult {
+  constructor(row, destination, status, newHash, existingHash) {
+    this.row = row;
+    this.destination = destination;
+    this.status = status;
+    this.newHash = newHash;
+    this.existingHash = existingHash;
+  }
+}
+
+function parseCli() {
+  const { values } = parseArgs({
+    allowPositionals: false,
+    options: {
+      source: { type: "string" },
+      mapping: { type: "string" },
+      "init-mapping": { type: "boolean", default: false },
+      force: { type: "boolean", default: false },
+      destination: { type: "string" },
+      "doc-root": { type: "string", default: "../requirements/documentation" },
+      "doc-slug": { type: "string" },
+      iteration: { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      "diff-report": { type: "string" },
+      "update-mapping-notes": { type: "boolean", default: false },
+      "trim-top": { type: "string", default: "0" },
+    },
+  });
+
+  if (!values.source) {
+    throw new Error("--source is required.");
+  }
+  if (!values.mapping) {
+    throw new Error("--mapping is required.");
+  }
+
+  const toInt = (name) => {
+    const value = Number(values[name]);
+    if (!Number.isFinite(value)) {
+      throw new Error(`Option --${name} must be a number.`);
+    }
+    return value;
+  };
+
+  return {
+    source: path.resolve(process.cwd(), values.source),
+    mapping: path.resolve(process.cwd(), values.mapping),
+    initMapping: Boolean(values["init-mapping"]),
+    force: Boolean(values.force),
+    destination: values.destination
+      ? path.resolve(process.cwd(), values.destination)
+      : undefined,
+    docRoot: path.resolve(process.cwd(), values["doc-root"]),
+    docSlug: values["doc-slug"],
+    iteration: values.iteration,
+    dryRun: Boolean(values["dry-run"]),
+    diffReport: values["diff-report"]
+      ? path.resolve(process.cwd(), values["diff-report"])
+      : undefined,
+    updateMappingNotes: Boolean(values["update-mapping-notes"]),
+    trimTop: toInt("trim-top"),
+  };
+}
+
+async function pathExists(target) {
+  try {
+    await fsp.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function ensureDirectory(dirPath) {
+  await fsp.mkdir(dirPath, { recursive: true });
+}
+
+async function discoverImages(sourceDir) {
+  const entries = await fsp.readdir(sourceDir, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isFile() && IMAGE_EXTS.has(path.extname(entry.name).toLowerCase()))
+    .map((entry) => entry.name)
+    .sort();
+}
+
+function stringifyCsvRow(values) {
+  return values
+    .map((value = "") => {
+      const str = String(value ?? "");
+      if (/[",\n\r]/.test(str)) {
+        return `"${str.replace(/"/g, '""')}"`;
+      }
+      return str;
+    })
+    .join(",");
+}
+
+function stringifyCsv(rows, header) {
+  const lines = [];
+  if (header) {
+    lines.push(stringifyCsvRow(header));
+  }
+  for (const row of rows) {
+    lines.push(stringifyCsvRow(row));
+  }
+  return `${lines.join("\n")}\n`;
+}
+
+function parseCsv(content) {
+  const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  const rows = [];
+  let field = "";
+  let row = [];
+  let inQuotes = false;
+
+  for (let i = 0; i < normalized.length; i += 1) {
+    const char = normalized[i];
+    if (inQuotes) {
+      if (char === '"') {
+        if (normalized[i + 1] === '"') {
+          field += '"';
+          i += 1;
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        field += char;
+      }
+    } else if (char === '"') {
+      inQuotes = true;
+    } else if (char === ',') {
+      row.push(field);
+      field = "";
+    } else if (char === "\n") {
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else {
+      field += char;
+    }
+  }
+
+  if (inQuotes) {
+    throw new Error("CSV parsing error: unterminated quoted field.");
+  }
+
+  if (field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+
+  return rows.filter((cells) => cells.some((cell) => cell.trim().length > 0));
+}
+
+async function writeMappingTemplate(images, mappingPath, force) {
+  if (await pathExists(mappingPath)) {
+    if (!force) {
+      throw new Error(
+        `Mapping file ${mappingPath} already exists. Pass --force to overwrite.`
+      );
+    }
+  }
+  await ensureDirectory(path.dirname(mappingPath));
+  const header = ["original_name", "file_slug", "version", "panel_title", "notes"];
+  const rows = images.map((name) => [name, path.parse(name).name, "", "", ""]);
+  await fsp.writeFile(mappingPath, stringifyCsv(rows, header), "utf8");
+}
+
+async function loadMapping(sourceDir, mappingPath) {
+  if (!(await pathExists(mappingPath))) {
+    throw new Error(`Mapping file ${mappingPath} does not exist. Run with --init-mapping first.`);
+  }
+  const content = await fsp.readFile(mappingPath, "utf8");
+  const rows = parseCsv(content);
+  if (!rows.length) {
+    throw new Error(`Mapping file ${mappingPath} has no rows.`);
+  }
+  const header = rows[0].map((col) => col.trim());
+  const required = ["original_name", "file_slug", "version", "panel_title", "notes"];
+  const missing = required.filter((col) => !header.includes(col));
+  if (missing.length) {
+    throw new Error(
+      `Mapping file ${mappingPath} is missing columns: ${missing.sort().join(", ")}`
+    );
+  }
+  const indexMap = new Map(header.map((col, idx) => [col, idx]));
+  const records = [];
+  for (let i = 1; i < rows.length; i += 1) {
+    const row = rows[i];
+    const lineNum = i + 1;
+    const get = (col) => (row[indexMap.get(col)] ?? "").trim();
+    const originalName = get("original_name");
+    const fileSlug = get("file_slug");
+    if (!originalName) {
+      continue;
+    }
+    const originalPath = path.join(sourceDir, originalName);
+    if (!(await pathExists(originalPath))) {
+      throw new Error(`Row ${lineNum}: source image ${originalPath} does not exist.`);
+    }
+    if (!fileSlug) {
+      throw new Error(`Row ${lineNum}: file_slug is required.`);
+    }
+    if (/[\\/]/.test(fileSlug)) {
+      throw new Error(
+        `Row ${lineNum}: file_slug '${fileSlug}' contains path separator characters.`
+      );
+    }
+    records.push(
+      new PanelRow({
+        originalName,
+        originalPath,
+        fileSlug,
+        version: get("version"),
+        panelTitle: get("panel_title"),
+        notes: get("notes"),
+      })
+    );
+  }
+  if (!records.length) {
+    throw new Error(`No rows found in mapping file ${mappingPath}.`);
+  }
+  return records;
+}
+
+function resolveDestination(args) {
+  if (args.destination) {
+    return args.destination;
+  }
+  if (!args.docSlug || !args.iteration) {
+    throw new Error(
+      "Either provide --destination or both --doc-slug and --iteration to resolve the final path."
+    );
+  }
+  return path.join(args.docRoot, args.docSlug, "assets", args.iteration);
+}
+
+async function fileSha256(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+async function preparePanelBuffer(srcPath, trimTop) {
+  if (trimTop <= 0) {
+    return fsp.readFile(srcPath);
+  }
+  const ext = path.extname(srcPath).toLowerCase();
+  const pipeline = sharp(srcPath);
+  const metadata = await pipeline.metadata();
+  if (!metadata.height || !metadata.width) {
+    throw new Error(`Unable to read image metadata for ${srcPath}.`);
+  }
+  const top = Math.min(trimTop, Math.max(metadata.height - 1, 0));
+  const height = Math.max(metadata.height - top, 1);
+  const formatter = FORMAT_MAP.get(ext) || "png";
+  return pipeline
+    .extract({ left: 0, top, width: metadata.width, height })
+    .toFormat(formatter)
+    .toBuffer();
+}
+
+async function evaluatePanel(preparedBuffer, destination) {
+  const newHash = crypto.createHash("sha256").update(preparedBuffer).digest("hex");
+  if (!(await pathExists(destination))) {
+    return { status: "missing", newHash, existingHash: null };
+  }
+  const existingHash = await fileSha256(destination);
+  if (existingHash === newHash) {
+    return { status: "identical", newHash, existingHash };
+  }
+  return { status: "different", newHash, existingHash };
+}
+
+async function copyPanels(rows, destDir, dryRun, trimTop) {
+  const results = [];
+  for (const row of rows) {
+    const target = path.join(destDir, `${row.finalStem()}${row.extension()}`);
+    const prepared = await preparePanelBuffer(row.originalPath, trimTop);
+    const evaluation = await evaluatePanel(prepared, target);
+    results.push(new CopyResult(row, target, evaluation.status, evaluation.newHash, evaluation.existingHash));
+    if (dryRun || evaluation.status === "identical") {
+      continue;
+    }
+    await ensureDirectory(path.dirname(target));
+    await fsp.writeFile(target, prepared);
+  }
+  return results;
+}
+
+async function writeDiffReport(results, reportPath) {
+  await ensureDirectory(path.dirname(reportPath));
+  const header = [
+    "original_name",
+    "export_name",
+    "destination",
+    "status",
+    "new_sha256",
+    "existing_sha256",
+  ];
+  const rows = results.map((res) => [
+    res.row.originalName,
+    `${res.row.finalStem()}${res.row.extension()}`,
+    res.destination,
+    res.status,
+    res.newHash,
+    res.existingHash || "",
+  ]);
+  await fsp.writeFile(reportPath, stringifyCsv(rows, header), "utf8");
+}
+
+function appendDiffNotes(rows, results) {
+  const noteMap = {
+    missing: "不一致：目标缺失",
+    different: "不一致：像素不一致",
+  };
+  rows.forEach((row, idx) => {
+    const result = results[idx];
+    if (!result) return;
+    const note = noteMap[result.status];
+    if (!note) return;
+    if (row.notes.includes(note)) return;
+    row.notes = row.notes ? `${row.notes}；${note}` : note;
+  });
+}
+
+async function writeMapping(rows, mappingPath) {
+  await ensureDirectory(path.dirname(mappingPath));
+  const header = ["original_name", "file_slug", "version", "panel_title", "notes"];
+  const dataRows = rows.map((row) => [
+    row.originalName,
+    row.fileSlug,
+    row.version,
+    row.panelTitle,
+    row.notes,
+  ]);
+  await fsp.writeFile(mappingPath, stringifyCsv(dataRows, header), "utf8");
+}
+
+async function main() {
+  const args = parseCli();
+  if (!(await pathExists(args.source))) {
+    throw new Error(`Source directory ${args.source} does not exist.`);
+  }
+  if (args.updateMappingNotes && args.dryRun) {
+    throw new Error("--update-mapping-notes cannot be combined with --dry-run.");
+  }
+
+  if (args.initMapping) {
+    const images = await discoverImages(args.source);
+    if (!images.length) {
+      throw new Error(`No image files found under ${args.source}.`);
+    }
+    await writeMappingTemplate(images, args.mapping, args.force);
+    console.log(`Wrote template mapping for ${images.length} panels to ${args.mapping}.`);
+    return;
+  }
+
+  const rows = await loadMapping(args.source, args.mapping);
+  const destDir = resolveDestination(args);
+  const results = await copyPanels(rows, destDir, args.dryRun, args.trimTop);
+
+  const summary = new Map();
+  for (const res of results) {
+    summary.set(res.status, (summary.get(res.status) || 0) + 1);
+    let action;
+    if (args.dryRun) {
+      action = "DRY-RUN";
+    } else if (res.status === "identical") {
+      action = "Skipped";
+    } else if (res.status === "missing") {
+      action = "Copied";
+    } else {
+      action = "Overwrote";
+    }
+    console.log(`${action} ${res.row.originalPath} -> ${res.destination} [${res.status}]`);
+  }
+
+  if (args.diffReport) {
+    await writeDiffReport(results, args.diffReport);
+    console.log(`Diff report written to ${args.diffReport}.`);
+  }
+
+  if (args.updateMappingNotes) {
+    appendDiffNotes(rows, results);
+    await writeMapping(rows, args.mapping);
+    console.log(`Mapping notes updated with diff status: ${args.mapping}.`);
+  }
+
+  const copies = (summary.get("missing") || 0) + (summary.get("different") || 0);
+  console.log(
+    `Evaluated ${results.length} panels under ${destDir} (copied ${copies}, identical ${
+      summary.get("identical") || 0
+    }).`
+  );
+}
+
+if (require.main === module) {
+  main().catch((err) => {
+    console.error(err.message || err);
+    process.exit(1);
+  });
+}

package/skills/aipk_development/GURU_AI.md

@@ -0,0 +1,8 @@
+# GURU AI Snapshot
+
+Last refreshed: 2025-11-12T09:25:07.317888+00:00
+
+| File | Last Modified (UTC) |
+| --- | --- |
+| `SKILL.md` | 2025-11-11T13:08:54.321712+00:00 |
+| `templates/实施计划文档.md` | 2025-11-12T07:51:57.026767+00:00 |

package/skills/aipk_development/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: development
+description: Development phase index pointing to the single authoritative implementation plan template.
+---
+
+# 开发阶段模板索引
+
+开发阶段目前仅保留一个标准化资产——`实施计划文档` 模板。所有与开发过程相关的说明、Checklist、交付要求都应在该模板中进行维护和引用。
+
+## 可用模板
+
+- [`实施计划文档`](./templates/实施计划文档.md) — 统一的执行计划模板，覆盖需求对齐、设计联动、开发排期、验收要求与发布交接等内容。
+
+## 使用说明
+
+1. 在创建或更新开发计划时，始终从上述模板拷贝，并保留原有结构。
+2. 如需新增章节或规范，请在模板中补充，并保持变更记录，确保后续项目能够复用。
+3. 若模板内容与其他文档存在冲突，以此模板为准，并在 `../requirements` 或 `../operations` 中补充引用说明。
+
+> 所有与开发执行相关的新材料（脚本、指南、Checklist）都应收敛到此模板，以确保唯一且可复用的来源。