@veolab/discoverylab 0.1.0

package/dist/chunk-VY3BLXBW.js

@@ -0,0 +1,329 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/db/index.ts
+import Database from "better-sqlite3";
+import { drizzle } from "drizzle-orm/better-sqlite3";
+import { mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  exportDestinations: () => exportDestinations,
+  exportRules: () => exportRules,
+  frames: () => frames,
+  projectExports: () => projectExports,
+  projects: () => projects,
+  settings: () => settings
+});
+import { sqliteTable, text, integer, real } from "drizzle-orm/sqlite-core";
+var projects = sqliteTable("projects", {
+  id: text("id").primaryKey(),
+  name: text("name").notNull(),
+  // Source
+  videoPath: text("video_path"),
+  thumbnailPath: text("thumbnail_path"),
+  // Best frame or image for project cover
+  platform: text("platform"),
+  // 'ios' | 'android' | 'web'
+  // Analysis
+  aiSummary: text("ai_summary"),
+  ocrText: text("ocr_text"),
+  ocrEngine: text("ocr_engine"),
+  ocrConfidence: real("ocr_confidence"),
+  frameCount: integer("frame_count").default(0),
+  duration: real("duration"),
+  // seconds
+  // Annotations
+  manualNotes: text("manual_notes"),
+  tags: text("tags"),
+  // JSON array
+  linkedTicket: text("linked_ticket"),
+  // e.g., "ABC-123"
+  // External integrations (legacy single URLs - maintained for backwards compatibility)
+  linkedJiraUrl: text("linked_jira_url"),
+  // Full Jira issue URL
+  linkedNotionUrl: text("linked_notion_url"),
+  // Notion page URL
+  linkedFigmaUrl: text("linked_figma_url"),
+  // Figma design URL (auto-detected from Jira or manual)
+  // Task Hub - Multiple links with metadata (JSON array)
+  taskHubLinks: text("task_hub_links"),
+  // JSON: [{ id, type, url, title, status, metadata }]
+  taskRequirements: text("task_requirements"),
+  // AI-generated requirements from linked content
+  taskTestMap: text("task_test_map"),
+  // AI-generated test map from linked content
+  // Status
+  status: text("status").default("draft"),
+  // 'draft' | 'analyzed' | 'exported' | 'archived'
+  // Timestamps
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+var projectExports = sqliteTable("project_exports", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  // Destination
+  destination: text("destination").notNull(),
+  // 'notion' | 'drive' | 'jira' | 'slack' | 'local'
+  destinationUrl: text("destination_url"),
+  destinationPath: text("destination_path"),
+  // Content included
+  contentIncluded: text("content_included"),
+  // JSON: { video, keyFrames, aiSummary, manualNotes }
+  // Status
+  status: text("status").default("pending"),
+  // 'pending' | 'in_progress' | 'completed' | 'failed'
+  errorMessage: text("error_message"),
+  // Timestamps
+  exportedAt: integer("exported_at", { mode: "timestamp" }),
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+});
+var frames = sqliteTable("frames", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => projects.id, { onDelete: "cascade" }),
+  // Frame data
+  frameNumber: integer("frame_number").notNull(),
+  timestamp: real("timestamp").notNull(),
+  // seconds
+  imagePath: text("image_path").notNull(),
+  // Analysis
+  ocrText: text("ocr_text"),
+  isKeyFrame: integer("is_key_frame", { mode: "boolean" }).default(false),
+  // Timestamps
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull()
+});
+var settings = sqliteTable("settings", {
+  key: text("key").primaryKey(),
+  value: text("value").notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+var exportDestinations = sqliteTable("export_destinations", {
+  id: text("id").primaryKey(),
+  // Destination config
+  type: text("type").notNull(),
+  // 'notion' | 'drive' | 'jira' | 'slack'
+  name: text("name").notNull(),
+  // User-friendly name
+  // Configuration (JSON)
+  config: text("config"),
+  // { workspaceUrl, folderId, projectKey, channelId, etc. }
+  // Status
+  isActive: integer("is_active", { mode: "boolean" }).default(true),
+  lastUsedAt: integer("last_used_at", { mode: "timestamp" }),
+  // Timestamps
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+var exportRules = sqliteTable("export_rules", {
+  id: text("id").primaryKey(),
+  // Rule definition
+  name: text("name").notNull(),
+  destinationId: text("destination_id").notNull().references(() => exportDestinations.id, { onDelete: "cascade" }),
+  // Trigger conditions (JSON)
+  conditions: text("conditions"),
+  // { tags: ['feature'], status: 'analyzed', platform: 'ios' }
+  // Content to include (JSON)
+  contentIncluded: text("content_included"),
+  // { video: true, keyFrames: true, aiSummary: true }
+  // Status
+  isActive: integer("is_active", { mode: "boolean" }).default(true),
+  // Timestamps
+  createdAt: integer("created_at", { mode: "timestamp" }).notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).notNull()
+});
+
+// src/db/index.ts
+var DATA_DIR = join(homedir(), ".discoverylab");
+var DB_PATH = join(DATA_DIR, "data.db");
+var PROJECTS_DIR = join(DATA_DIR, "projects");
+var EXPORTS_DIR = join(DATA_DIR, "exports");
+var FRAMES_DIR = join(DATA_DIR, "frames");
+function ensureDirectories() {
+  const dirs = [DATA_DIR, PROJECTS_DIR, EXPORTS_DIR, FRAMES_DIR];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+function createTables(sqlite) {
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      video_path TEXT,
+      thumbnail_path TEXT,
+      platform TEXT,
+      ai_summary TEXT,
+      ocr_text TEXT,
+      ocr_engine TEXT,
+      ocr_confidence REAL,
+      frame_count INTEGER DEFAULT 0,
+      duration REAL,
+      manual_notes TEXT,
+      tags TEXT,
+      linked_ticket TEXT,
+      linked_jira_url TEXT,
+      linked_notion_url TEXT,
+      linked_figma_url TEXT,
+      task_hub_links TEXT,
+      task_requirements TEXT,
+      task_test_map TEXT,
+      status TEXT DEFAULT 'draft',
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN thumbnail_path TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN linked_jira_url TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN linked_notion_url TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN linked_figma_url TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN task_hub_links TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN task_requirements TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN task_test_map TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN ocr_engine TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN ocr_confidence REAL`);
+  } catch (e) {
+  }
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS project_exports (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      destination TEXT NOT NULL,
+      destination_url TEXT,
+      destination_path TEXT,
+      content_included TEXT,
+      status TEXT DEFAULT 'pending',
+      error_message TEXT,
+      exported_at INTEGER,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    )
+  `);
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS frames (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      frame_number INTEGER NOT NULL,
+      timestamp REAL NOT NULL,
+      image_path TEXT NOT NULL,
+      ocr_text TEXT,
+      is_key_frame INTEGER DEFAULT 0,
+      created_at INTEGER NOT NULL,
+      FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE
+    )
+  `);
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS settings (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS export_destinations (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL,
+      name TEXT NOT NULL,
+      config TEXT,
+      is_active INTEGER DEFAULT 1,
+      last_used_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+  sqlite.exec(`
+    CREATE TABLE IF NOT EXISTS export_rules (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      destination_id TEXT NOT NULL,
+      conditions TEXT,
+      content_included TEXT,
+      is_active INTEGER DEFAULT 1,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      FOREIGN KEY (destination_id) REFERENCES export_destinations(id) ON DELETE CASCADE
+    )
+  `);
+  sqlite.exec(`
+    CREATE INDEX IF NOT EXISTS idx_projects_status ON projects(status);
+    CREATE INDEX IF NOT EXISTS idx_projects_platform ON projects(platform);
+    CREATE INDEX IF NOT EXISTS idx_project_exports_project_id ON project_exports(project_id);
+    CREATE INDEX IF NOT EXISTS idx_project_exports_destination ON project_exports(destination);
+    CREATE INDEX IF NOT EXISTS idx_frames_project_id ON frames(project_id);
+    CREATE INDEX IF NOT EXISTS idx_frames_is_key_frame ON frames(is_key_frame);
+  `);
+}
+var _db = null;
+var _sqlite = null;
+function getDatabase() {
+  if (!_db) {
+    ensureDirectories();
+    _sqlite = new Database(DB_PATH);
+    _sqlite.pragma("journal_mode = WAL");
+    _sqlite.pragma("foreign_keys = ON");
+    createTables(_sqlite);
+    _db = drizzle(_sqlite, { schema: schema_exports });
+  }
+  return _db;
+}
+function getSqlite() {
+  if (!_sqlite) {
+    getDatabase();
+  }
+  return _sqlite;
+}
+function closeDatabase() {
+  if (_sqlite) {
+    _sqlite.close();
+    _sqlite = null;
+    _db = null;
+  }
+}
+
+export {
+  projects,
+  projectExports,
+  frames,
+  settings,
+  exportDestinations,
+  exportRules,
+  DATA_DIR,
+  DB_PATH,
+  PROJECTS_DIR,
+  EXPORTS_DIR,
+  FRAMES_DIR,
+  getDatabase,
+  getSqlite,
+  closeDatabase
+};

package/dist/chunk-W3WJGYR6.js

@@ -0,0 +1,354 @@
+// src/core/analyze/ocr.ts
+import { execSync, spawn } from "child_process";
+import { existsSync, writeFileSync, unlinkSync } from "fs";
+import { join, dirname } from "path";
+import { platform, tmpdir } from "os";
+import { randomUUID } from "crypto";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function getSwiftHelperPath() {
+  const possiblePaths = [
+    join(__dirname, "..", "..", "swift", "VisionHelper"),
+    join(__dirname, "..", "..", "..", "src", "swift", "VisionHelper"),
+    join(process.cwd(), "src", "swift", "VisionHelper")
+  ];
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return possiblePaths[0];
+}
+async function recognizeTextWithVision(imagePath, options = {}) {
+  if (platform() !== "darwin") {
+    return { success: false, error: "Apple Vision is only available on macOS", engine: "vision" };
+  }
+  if (!existsSync(imagePath)) {
+    return { success: false, error: `Image file not found: ${imagePath}`, engine: "vision" };
+  }
+  const helperPath = getSwiftHelperPath();
+  if (existsSync(helperPath)) {
+    return runSwiftHelper(helperPath, imagePath, options);
+  }
+  return runVisionViaAppleScript(imagePath, options);
+}
+async function runSwiftHelper(helperPath, imagePath, options) {
+  return new Promise((resolve) => {
+    const args = ["ocr", imagePath];
+    if (options.recognitionLevel === "fast") {
+      args.push("--fast");
+    }
+    if (options.languages?.length) {
+      args.push("--languages", options.languages.join(","));
+    }
+    const proc = spawn(helperPath, args);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        resolve({ success: false, error: stderr || "VisionHelper failed", engine: "vision" });
+        return;
+      }
+      try {
+        const result = JSON.parse(stdout);
+        resolve({
+          success: true,
+          text: result.text,
+          blocks: result.blocks,
+          confidence: result.confidence,
+          engine: "vision"
+        });
+      } catch {
+        resolve({
+          success: true,
+          text: stdout.trim(),
+          engine: "vision"
+        });
+      }
+    });
+    proc.on("error", (err) => {
+      resolve({ success: false, error: err.message, engine: "vision" });
+    });
+  });
+}
+async function runVisionViaAppleScript(imagePath, _options) {
+  const swiftCode = `
+import Cocoa
+import Vision
+
+let imagePath = "${imagePath.replace(/"/g, '\\"')}"
+guard let image = NSImage(contentsOfFile: imagePath),
+      let cgImage = image.cgImage(forProposedRect: nil, context: nil, hints: nil) else {
+    print("Error: Could not load image")
+    exit(1)
+}
+
+let request = VNRecognizeTextRequest()
+request.recognitionLevel = .accurate
+request.recognitionLanguages = ["en-US"]
+
+let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
+try? handler.perform([request])
+
+var allText = ""
+if let results = request.results {
+    for observation in results {
+        if let candidate = observation.topCandidates(1).first {
+            allText += candidate.string + "\\n"
+        }
+    }
+}
+
+print(allText)
+`;
+  const tempFile = join(tmpdir(), `vision-ocr-${randomUUID()}.swift`);
+  try {
+    writeFileSync(tempFile, swiftCode);
+    const output = execSync(`swift ${tempFile}`, {
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    unlinkSync(tempFile);
+    return {
+      success: true,
+      text: output.trim(),
+      engine: "vision"
+    };
+  } catch (error) {
+    try {
+      unlinkSync(tempFile);
+    } catch {
+    }
+    const message = error instanceof Error ? error.message : "Vision OCR failed";
+    return { success: false, error: message, engine: "vision" };
+  }
+}
+async function recognizeTextWithTesseract(imagePath, options = {}) {
+  if (!existsSync(imagePath)) {
+    return { success: false, error: `Image file not found: ${imagePath}`, engine: "tesseract" };
+  }
+  try {
+    execSync("tesseract --version", { stdio: "ignore" });
+  } catch {
+    return { success: false, error: "Tesseract is not installed", engine: "tesseract" };
+  }
+  return new Promise((resolve) => {
+    const args = [imagePath, "stdout"];
+    if (options.languages?.length) {
+      args.push("-l", options.languages.join("+"));
+    }
+    args.push("--psm", "3");
+    args.push("-c", "tessedit_create_hocr=0");
+    const proc = spawn("tesseract", args);
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0 && !stdout) {
+        resolve({ success: false, error: stderr || "Tesseract failed", engine: "tesseract" });
+        return;
+      }
+      resolve({
+        success: true,
+        text: stdout.trim(),
+        engine: "tesseract"
+      });
+    });
+    proc.on("error", (err) => {
+      resolve({ success: false, error: err.message, engine: "tesseract" });
+    });
+  });
+}
+async function recognizeText(imagePath, options = {}) {
+  if (platform() === "darwin") {
+    const visionResult = await recognizeTextWithVision(imagePath, options);
+    if (visionResult.success) {
+      return visionResult;
+    }
+    console.warn("Vision OCR failed, trying Tesseract:", visionResult.error);
+  }
+  return recognizeTextWithTesseract(imagePath, options);
+}
+async function recognizeTextBatch(imagePaths, options = {}) {
+  const results = [];
+  const textParts = [];
+  for (const imagePath of imagePaths) {
+    const ocr = await recognizeText(imagePath, options);
+    results.push({ imagePath, ocr });
+    if (ocr.success && ocr.text) {
+      textParts.push(ocr.text);
+    }
+  }
+  return {
+    success: results.some((r) => r.ocr.success),
+    results,
+    totalText: textParts.join("\n\n---\n\n")
+  };
+}
+function analyzeText(text) {
+  if (!text || text.trim().length === 0) {
+    return {
+      wordCount: 0,
+      uniqueWords: 0,
+      sentences: [],
+      keywords: []
+    };
+  }
+  const words = text.toLowerCase().split(/\s+/).filter((w) => w.length > 0).map((w) => w.replace(/[^\w]/g, ""));
+  const uniqueWords = new Set(words);
+  const sentences = text.split(/[.!?]+/).map((s) => s.trim()).filter((s) => s.length > 0);
+  const wordFreq = /* @__PURE__ */ new Map();
+  const stopWords = /* @__PURE__ */ new Set([
+    "the",
+    "a",
+    "an",
+    "is",
+    "are",
+    "was",
+    "were",
+    "be",
+    "been",
+    "being",
+    "have",
+    "has",
+    "had",
+    "do",
+    "does",
+    "did",
+    "will",
+    "would",
+    "could",
+    "should",
+    "may",
+    "might",
+    "must",
+    "shall",
+    "can",
+    "need",
+    "dare",
+    "to",
+    "of",
+    "in",
+    "for",
+    "on",
+    "with",
+    "at",
+    "by",
+    "from",
+    "up",
+    "about",
+    "into",
+    "through",
+    "during",
+    "before",
+    "after",
+    "above",
+    "below",
+    "between",
+    "under",
+    "again",
+    "further",
+    "then",
+    "once",
+    "and",
+    "but",
+    "or",
+    "nor",
+    "so",
+    "yet",
+    "both",
+    "either",
+    "neither",
+    "not",
+    "only",
+    "own",
+    "same",
+    "than",
+    "too",
+    "very",
+    "just",
+    "it",
+    "its",
+    "this",
+    "that",
+    "these",
+    "those",
+    "i",
+    "you",
+    "he",
+    "she",
+    "we",
+    "they",
+    "me",
+    "him",
+    "her",
+    "us",
+    "them",
+    "my",
+    "your"
+  ]);
+  for (const word of words) {
+    if (word.length > 2 && !stopWords.has(word)) {
+      wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
+    }
+  }
+  const keywords = Array.from(wordFreq.entries()).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([word]) => word);
+  return {
+    wordCount: words.length,
+    uniqueWords: uniqueWords.size,
+    sentences,
+    keywords
+  };
+}
+function checkVisionAvailable() {
+  if (platform() !== "darwin") {
+    return false;
+  }
+  try {
+    execSync('swift -e "import Vision"', { stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkTesseractAvailable() {
+  try {
+    execSync("tesseract --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getAvailableOCREngines() {
+  const engines = [];
+  if (checkVisionAvailable()) {
+    engines.push("vision");
+  }
+  if (checkTesseractAvailable()) {
+    engines.push("tesseract");
+  }
+  return engines;
+}
+
+export {
+  recognizeTextWithVision,
+  recognizeTextWithTesseract,
+  recognizeText,
+  recognizeTextBatch,
+  analyzeText,
+  checkVisionAvailable,
+  checkTesseractAvailable,
+  getAvailableOCREngines
+};

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node