@jungjaehoon/mama-os 0.25.0 → 0.27.0

package/scripts/attachment/extract-office-text.js

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+
+const { readFileSync, statSync } = require('node:fs');
+const { inflateRawSync } = require('node:zlib');
+
+const MAX_ARCHIVE_BYTES = 64 * 1024 * 1024;
+const MAX_ARCHIVE_ENTRIES = 2_000;
+
+const [, , filePath, extension, maxOutputRaw] = process.argv;
+const maxOutputBytes = Number(maxOutputRaw);
+if (!filePath || !['.docx', '.xlsx'].includes(extension) || !Number.isSafeInteger(maxOutputBytes)) {
+  throw new Error('usage: extract-office-text.js <path> <.docx|.xlsx> <max-output-bytes>');
+}
+
+const prefixes =
+  extension === '.docx' ? ['word/document.xml'] : ['xl/sharedStrings.xml', 'xl/worksheets/'];
+const entries = readOfficeEntries(filePath, prefixes);
+const text = extension === '.docx' ? extractDocxText(entries) : extractXlsxText(entries);
+process.stdout.write(truncateUtf8(text, maxOutputBytes));
+
+function readOfficeEntries(path, wantedPrefixes) {
+  if (statSync(path).size > MAX_ARCHIVE_BYTES) {
+    throw new Error('Office attachment is too large');
+  }
+  const archive = readFileSync(path);
+  const endOffset = findEndOfCentralDirectory(archive);
+  const entryCount = archive.readUInt16LE(endOffset + 10);
+  const centralOffset = archive.readUInt32LE(endOffset + 16);
+  if (entryCount > MAX_ARCHIVE_ENTRIES) {
+    throw new Error('Office attachment has too many entries');
+  }
+  const result = new Map();
+  let cursor = centralOffset;
+  let extractedBytes = 0;
+  for (let index = 0; index < entryCount; index += 1) {
+    requireSignature(archive, cursor, 0x02014b50, 'central directory');
+    const flags = archive.readUInt16LE(cursor + 8);
+    const method = archive.readUInt16LE(cursor + 10);
+    const compressedSize = archive.readUInt32LE(cursor + 20);
+    const uncompressedSize = archive.readUInt32LE(cursor + 24);
+    const nameLength = archive.readUInt16LE(cursor + 28);
+    const extraLength = archive.readUInt16LE(cursor + 30);
+    const commentLength = archive.readUInt16LE(cursor + 32);
+    const localOffset = archive.readUInt32LE(cursor + 42);
+    const nameStart = cursor + 46;
+    const name = archive.subarray(nameStart, nameStart + nameLength).toString('utf8');
+    cursor = nameStart + nameLength + extraLength + commentLength;
+    if (!wantedPrefixes.some((prefix) => name === prefix || name.startsWith(prefix))) {
+      continue;
+    }
+    if ((flags & 0x1) !== 0) {
+      throw new Error('Encrypted Office attachments are not supported');
+    }
+    extractedBytes += uncompressedSize;
+    if (extractedBytes > MAX_ARCHIVE_BYTES) {
+      throw new Error('Office attachment expands too far');
+    }
+    requireSignature(archive, localOffset, 0x04034b50, 'local file header');
+    const nameSize = archive.readUInt16LE(localOffset + 26);
+    const extraSize = archive.readUInt16LE(localOffset + 28);
+    const dataStart = localOffset + 30 + nameSize + extraSize;
+    const compressed = archive.subarray(dataStart, dataStart + compressedSize);
+    const data =
+      method === 0
+        ? compressed
+        : method === 8
+          ? inflateRawSync(compressed, { maxOutputLength: MAX_ARCHIVE_BYTES })
+          : unsupportedCompression(method);
+    if (data.length !== uncompressedSize) {
+      throw new Error('Corrupt Office entry');
+    }
+    result.set(name, data.toString('utf8'));
+  }
+  return result;
+}
+
+function findEndOfCentralDirectory(archive) {
+  const minimumOffset = Math.max(0, archive.length - 65_557);
+  for (let cursor = archive.length - 22; cursor >= minimumOffset; cursor -= 1) {
+    if (archive.readUInt32LE(cursor) === 0x06054b50) {
+      return cursor;
+    }
+  }
+  throw new Error('Invalid Office attachment: ZIP directory not found');
+}
+
+function requireSignature(archive, offset, expected, label) {
+  if (offset < 0 || offset + 4 > archive.length || archive.readUInt32LE(offset) !== expected) {
+    throw new Error(`Invalid Office attachment ${label}`);
+  }
+}
+
+function unsupportedCompression(method) {
+  throw new Error(`Unsupported Office compression method: ${method}`);
+}
+
+function extractDocxText(entries) {
+  const xml = entries.get('word/document.xml');
+  if (!xml) {
+    throw new Error('Invalid DOCX attachment: word/document.xml is missing');
+  }
+  return [...xml.matchAll(/<w:p\b[^>]*>([\s\S]*?)<\/w:p>/g)]
+    .map((match) => extractXmlText(match[1], 'w:t'))
+    .filter(Boolean)
+    .join('\n');
+}
+
+function extractXlsxText(entries) {
+  const sharedXml = entries.get('xl/sharedStrings.xml') || '';
+  const shared = [...sharedXml.matchAll(/<si\b[^>]*>([\s\S]*?)<\/si>/g)].map((match) =>
+    extractXmlText(match[1], 't')
+  );
+  const sheets = [...entries.entries()]
+    .filter(([name]) => /^xl\/worksheets\/sheet[^/]*\.xml$/.test(name))
+    .sort(([left], [right]) => left.localeCompare(right));
+  if (sheets.length === 0) {
+    throw new Error('Invalid XLSX attachment: no worksheets found');
+  }
+  const lines = [];
+  for (const [name, xml] of sheets) {
+    lines.push(`[${name.slice(name.lastIndexOf('/') + 1, -4)}]`);
+    for (const cell of xml.matchAll(/<c\b([^>]*)>([\s\S]*?)<\/c>/g)) {
+      const reference = readXmlAttribute(cell[1], 'r') || '?';
+      const type = readXmlAttribute(cell[1], 't');
+      const raw = firstXmlTagText(cell[2], 'v');
+      const value =
+        type === 's'
+          ? shared[Number(raw)] || ''
+          : type === 'inlineStr'
+            ? extractXmlText(cell[2], 't')
+            : decodeXmlEntities(raw);
+      if (value) {
+        lines.push(`${reference}=${value}`);
+      }
+    }
+  }
+  return lines.join('\n');
+}
+
+function extractXmlText(xml, tagName) {
+  const tag = tagName.replace(':', '\\:');
+  return [...xml.matchAll(new RegExp(`<${tag}\\b[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'g'))]
+    .map((match) => decodeXmlEntities(match[1]))
+    .join('');
+}
+
+function firstXmlTagText(xml, tagName) {
+  const match = new RegExp(`<${tagName}\\b[^>]*>([\\s\\S]*?)<\\/${tagName}>`).exec(xml);
+  return match ? decodeXmlEntities(match[1]) : '';
+}
+
+function readXmlAttribute(attributes, name) {
+  const match = new RegExp(`(?:^|\\s)${name}=(?:"([^"]*)"|'([^']*)')`).exec(attributes);
+  return match ? match[1] || match[2] : undefined;
+}
+
+function decodeXmlEntities(value) {
+  return value
+    .replace(/<[^>]+>/g, '')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, '&')
+    .replace(/&#(\d+);/g, (_match, code) => String.fromCodePoint(Number(code)))
+    .replace(/&#x([0-9a-f]+);/gi, (_match, code) => String.fromCodePoint(parseInt(code, 16)));
+}
+
+function truncateUtf8(content, maxBytes) {
+  const bytes = Buffer.from(content);
+  if (bytes.length <= maxBytes) {
+    return content;
+  }
+  let end = maxBytes;
+  while (end > 0 && (bytes[end] & 0xc0) === 0x80) {
+    end -= 1;
+  }
+  return `${bytes.subarray(0, end).toString('utf8')}\n\n[Truncated at ${maxBytes} bytes]`;
+}

package/scripts/attachment/extract-pdf-text.swift

@@ -0,0 +1,36 @@
+import Foundation
+import PDFKit
+
+guard CommandLine.arguments.count == 3, let maxBytes = Int(CommandLine.arguments[2]), maxBytes > 0 else {
+  fputs("usage: extract-pdf-text.swift <pdf-path> <max-output-bytes>\n", stderr)
+  exit(2)
+}
+
+let url = URL(fileURLWithPath: CommandLine.arguments[1])
+guard let document = PDFDocument(url: url) else {
+  fputs("unable to open PDF\n", stderr)
+  exit(1)
+}
+
+var written = 0
+for index in 0..<document.pageCount {
+  if let text = document.page(at: index)?.string, !text.isEmpty {
+    let separator = written == 0 ? "" : "\n\n"
+    let data = (separator + text).data(using: .utf8) ?? Data()
+    let remaining = maxBytes - written
+    if remaining <= 0 { break }
+    var bounded = Data()
+    var prefixLength = min(remaining, data.count)
+    while prefixLength > 0 {
+      let candidate = Data(data.prefix(prefixLength))
+      if String(data: candidate, encoding: .utf8) != nil {
+        bounded = candidate
+        break
+      }
+      prefixLength -= 1
+    }
+    FileHandle.standardOutput.write(bounded)
+    written += bounded.count
+    if bounded.count < data.count { break }
+  }
+}

package/scripts/image/fb-overlay.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Render translated text over OCR regions and return the output path as JSON."""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+
+PADDING = 10
+MIN_FONT_SIZE = 18
+
+
+def font_candidates():
+    configured = os.environ.get("MAMA_KOREAN_FONT")
+    return [
+        configured,
+        "/System/Library/Fonts/AppleSDGothicNeo.ttc",
+        "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
+        "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc",
+    ]
+
+
+def load_font(image_draw, text, max_width, start_size):
+    from PIL import ImageFont
+
+    for candidate in font_candidates():
+        if not candidate or not Path(candidate).exists():
+            continue
+        size = max(start_size, MIN_FONT_SIZE)
+        while size >= MIN_FONT_SIZE:
+            font = ImageFont.truetype(candidate, size)
+            bounds = image_draw.textbbox((0, 0), text, font=font)
+            if bounds[2] - bounds[0] <= max_width or size == MIN_FONT_SIZE:
+                return font
+            size -= 1
+    raise RuntimeError("Korean font not found; set MAMA_KOREAN_FONT")
+
+
+def sample_text_color(array, points):
+    import numpy
+
+    x1 = max(min(point[0] for point in points), 0)
+    y1 = max(min(point[1] for point in points), 0)
+    x2 = min(max(point[0] for point in points), array.shape[1])
+    y2 = min(max(point[1] for point in points), array.shape[0])
+    region = array[y1:y2, x1:x2]
+    if region.size == 0:
+        return (20, 20, 20)
+    dark_pixels = region.reshape(-1, 3)[region.mean(axis=2).flatten() < 80]
+    if len(dark_pixels) < 3:
+        return (20, 20, 20)
+    return tuple(int(channel) for channel in dark_pixels.mean(axis=0))
+
+
+def main():
+    if len(sys.argv) < 3:
+        raise ValueError("Usage: fb-overlay.py <image> <annotations.json> [output.png]")
+
+    from PIL import Image, ImageDraw
+    import numpy
+
+    image_path = sys.argv[1]
+    annotations_path = sys.argv[2]
+    output_path = (
+        sys.argv[3]
+        if len(sys.argv) > 3
+        else str(Path(image_path).with_name(f"{Path(image_path).stem}_KR.png"))
+    )
+    with open(annotations_path, encoding="utf-8") as handle:
+        annotations = json.load(handle)
+
+    original = Image.open(image_path).convert("RGB")
+    image = original.copy()
+    pixels = numpy.array(original)
+    draw = ImageDraw.Draw(image)
+    render_items = []
+
+    for annotation in annotations:
+        points = annotation["bbox"]
+        translated = annotation.get("translated", "")
+        if not translated:
+            continue
+        x1 = min(point[0] for point in points)
+        y1 = min(point[1] for point in points)
+        x2 = max(point[0] for point in points)
+        y2 = max(point[1] for point in points)
+        font = load_font(draw, translated, x2 - x1, int((y2 - y1) * 0.92))
+        bounds = draw.textbbox((0, 0), translated, font=font)
+        width = bounds[2] - bounds[0]
+        height = bounds[3] - bounds[1]
+        render_items.append(
+            {
+                "box": (
+                    x1 - PADDING,
+                    y1 - PADDING,
+                    max(x2, x1 + width) + PADDING,
+                    max(y2, y1 + height + 4) + PADDING,
+                ),
+                "text": translated,
+                "font": font,
+                "color": sample_text_color(pixels, points),
+                "height": height,
+            }
+        )
+
+    for item in render_items:
+        draw.rectangle(list(item["box"]), fill=(255, 255, 255))
+    for item in render_items:
+        x1, y1, _x2, y2 = item["box"]
+        text_y = y1 + ((y2 - y1) - item["height"]) // 2
+        draw.text(
+            (x1 + PADDING, text_y),
+            item["text"],
+            font=item["font"],
+            fill=item["color"],
+        )
+
+    image.save(output_path, quality=95)
+    print(json.dumps({"outputPath": output_path}, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as error:
+        print(json.dumps({"error": str(error)}, ensure_ascii=False), file=sys.stderr)
+        sys.exit(1)

package/scripts/image/ocr-image.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Extract OCR regions as JSON for MAMA image translation tools."""
+
+import json
+import sys
+
+
+def main():
+    if len(sys.argv) < 2:
+        raise ValueError("Usage: ocr-image.py <image_path> [--lang ja,en]")
+
+    image_path = sys.argv[1]
+    languages = ["ja", "en"]
+    for index, argument in enumerate(sys.argv[2:], 2):
+        if argument == "--lang" and index + 1 < len(sys.argv):
+            languages = sys.argv[index + 1].split(",")
+
+    import easyocr
+
+    reader = easyocr.Reader(languages, gpu=False, verbose=False)
+    output = []
+    for bbox, text, confidence in reader.readtext(image_path, detail=1):
+        output.append(
+            {
+                "bbox": [[int(point[0]), int(point[1])] for point in bbox],
+                "text": text,
+                "conf": round(confidence, 2),
+            }
+        )
+    print(json.dumps(output, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as error:
+        print(json.dumps({"error": str(error)}, ensure_ascii=False), file=sys.stderr)
+        sys.exit(1)

package/scripts/setup-ocr.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+const { existsSync, mkdirSync } = require('node:fs');
+const { homedir } = require('node:os');
+const { dirname, join, resolve } = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const REQUIREMENTS = ['easyocr==1.7.2', 'Pillow>=10,<13', 'numpy>=1.26,<3'];
+const FONT_GUIDANCE =
+  'Install a Korean/CJK font (Ubuntu/Debian: apt install fonts-noto-cjk) or set ' +
+  'MAMA_KOREAN_FONT to a readable .ttf/.ttc font file.';
+const RUNTIME_CHECK = String.raw`
+import os
+from pathlib import Path
+import easyocr, PIL, numpy
+from PIL import ImageFont
+
+candidates = [
+    os.environ.get("MAMA_KOREAN_FONT"),
+    "/System/Library/Fonts/AppleSDGothicNeo.ttc",
+    "/usr/share/fonts/opentype/noto/NotoSansCJK-Regular.ttc",
+    "/usr/share/fonts/truetype/noto/NotoSansCJK-Regular.ttc",
+]
+for candidate in candidates:
+    if not candidate or not Path(candidate).is_file():
+        continue
+    try:
+        font = ImageFont.truetype(candidate, 18)
+        if font.getbbox("한글"):
+            print(easyocr.__version__)
+            raise SystemExit(0)
+    except OSError:
+        pass
+raise SystemExit("Korean/CJK font is unavailable")
+`;
+
+function runtimeRoot() {
+  return resolve(process.env.MAMA_OCR_ENV || join(homedir(), '.mama', 'ocr-env'));
+}
+
+function runtimePython(root) {
+  return process.platform === 'win32'
+    ? join(root, 'Scripts', 'python.exe')
+    : join(root, 'bin', 'python3');
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    stdio: options.capture ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+    encoding: 'utf8',
+    env: process.env,
+  });
+  if (result.error || result.status !== 0) {
+    const detail = result.error?.message || result.stderr?.trim() || `exit ${result.status}`;
+    throw new Error(`${command} ${args.join(' ')} failed: ${detail}`);
+  }
+  return result.stdout || '';
+}
+
+function check() {
+  const python = runtimePython(runtimeRoot());
+  if (!existsSync(python)) {
+    return false;
+  }
+  try {
+    run(python, ['-c', RUNTIME_CHECK], { capture: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function setup() {
+  const root = runtimeRoot();
+  const bootstrapPython = process.env.MAMA_OCR_BOOTSTRAP_PYTHON || 'python3';
+  mkdirSync(dirname(root), { recursive: true, mode: 0o700 });
+  if (!existsSync(runtimePython(root))) {
+    run(bootstrapPython, ['-m', 'venv', root]);
+  }
+  const python = runtimePython(root);
+  run(python, ['-m', 'pip', 'install', '--upgrade', 'pip']);
+  run(python, ['-m', 'pip', 'install', ...REQUIREMENTS]);
+  if (!check()) {
+    throw new Error(`MAMA OCR runtime failed its dependency/font check. ${FONT_GUIDANCE}`);
+  }
+  process.stdout.write(`MAMA OCR runtime ready: ${python}\n`);
+}
+
+function main() {
+  const command = process.argv[2];
+  if (command === '--print-requirements') {
+    process.stdout.write(`${REQUIREMENTS.join('\n')}\n`);
+    return;
+  }
+  if (command === '--print-font-guidance') {
+    process.stdout.write(`${FONT_GUIDANCE}\n`);
+    return;
+  }
+  if (command === '--check') {
+    if (check()) {
+      process.stdout.write(`MAMA OCR runtime ready: ${runtimePython(runtimeRoot())}\n`);
+      return;
+    }
+    process.stderr.write(
+      `MAMA OCR runtime is not ready at ${runtimeRoot()}. Run: pnpm setup:ocr\n${FONT_GUIDANCE}\n`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  setup();
+}
+
+try {
+  main();
+} catch (error) {
+  process.stderr.write(
+    `MAMA OCR setup failed: ${error instanceof Error ? error.message : error}\n`
+  );
+  process.exitCode = 1;
+}

package/templates/skills/image-translate.md

@@ -21,38 +21,33 @@ discordScreenshot: true
 
 이미지에서 텍스트를 추출하고 한국어로 번역하세요.
 
-**⚠️ 절대 지켜야 할 것:**
+## 결과 원칙
 
 - 메모리 컨텍스트(<relevant-memories> 태그 안의 내용)는 절대 출력하지 마세요
-- 도구 이름, 이모지, 메타 정보를 출력하지 마세요
-- 순수하게 이미지 번역 결과만 출력하세요
+- 이미지가 대화에 직접 포함됐다면 내용을 보고 번역하세요
+- 이미지가 파일·Drive·메시지 첨부 등 외부 위치에 있다면 현재 허용된 도구로 가져오세요
+- 사용자가 파일 생성·업로드·전송까지 요청했다면 사용 가능한 도구를 조합해 요청한 최종 결과까지 수행하세요
+- 쓰기·업로드·전송은 각 도구의 성공 응답을 확인하기 전에는 완료했다고 말하지 마세요
 
-## 절대 규칙
+## 번역 품질
 
-1. **번역 결과만 출력** - 설명, 요약, 코멘트 금지
-2. **모든 텍스트 번역** - 하나도 빠뜨리지 마세요
-3. **원본 구조 유지** - 제목, 목록, 표 그대로
-4. **도구 사용 금지** - Read, mama_search, mama_save 등 어떤 도구도 사용하지 마세요. 이미지만 보고 직접 번역하세요.
+1. 모든 텍스트를 빠뜨리지 말고 번역하세요
+2. 읽을 수 없거나 OCR이 불확실한 부분은 임의로 추정하지 말고 `[판독 불가]`로 표시하세요
+3. 제목, 목록, 표, 말풍선 순서 등 원본 구조를 유지하세요
+4. 단순 번역 요청이면 번역 결과만 출력하세요
+5. 일부 텍스트를 읽거나 번역하지 못했다면 해당 항목을 부분 실패로 명확히 보고하세요
+6. 산출물이나 전달을 요청받았다면 실제 결과와 실패 항목을 파일별로 명확히 보고하세요
 
 ## 금지 사항
 
-❌ "이 이미지는 ~입니다"
-❌ "번역 결과입니다:"
-❌ "완료했습니다"
-❌ 요약이나 설명
-❌ 이모지
-❌ **도구 호출** - Read, mama_search, mama_save, Write 등 절대 사용 금지
-❌ "이미지를 읽을 수 없습니다" - 이미지가 이미 제공되었으므로 직접 번역만 하세요
+- 메모리 컨텍스트나 비공개 경로를 최종 답변에 노출하지 마세요
+- 실행하지 않은 파일 생성·업로드·전송을 완료했다고 보고하지 마세요
+- 사용할 수 있는 도구가 있는데도 직접 도구와 Code-Act 내부 도구를 혼동해 “도구가 없다”고 단정하지 마세요
 
 ## 출력 형식
 
-그냥 번역된 텍스트만. 마크다운 사용 가능.
-
-**중요**:
-
-- 이미지는 이미 컨텍스트에 포함되어 있습니다. 도구를 호출하지 말고 바로 번역을 시작하세요.
-- "📚 메모리", "⏱️ 1턴", 도구 이름 등 메타 정보를 출력하지 마세요.
-- 테이블, 헤더, 메타데이터 없이 순수 번역만 출력하세요.
+- 단순 번역: 번역된 텍스트만 출력합니다
+- 산출물 요청: 생성·저장·전달된 결과와 실제 상태만 간결히 출력합니다
 
 ## 예시