chainlesschain 0.37.8 → 0.37.10

package/src/lib/note-versioning.js

@@ -0,0 +1,244 @@
+/**
+ * Note version control — track changes to notes with full history.
+ */
+
+/**
+ * Ensure the note_versions table exists.
+ */
+export function ensureVersionsTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS note_versions (
+      id TEXT PRIMARY KEY,
+      note_id TEXT NOT NULL,
+      version INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      content TEXT DEFAULT '',
+      tags TEXT DEFAULT '[]',
+      category TEXT DEFAULT 'general',
+      change_type TEXT DEFAULT 'edit',
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+}
+
+/**
+ * Generate a simple ID.
+ */
+function generateId() {
+  const hex = () =>
+    Math.floor(Math.random() * 0x10000)
+      .toString(16)
+      .padStart(4, "0");
+  return `${hex()}${hex()}-${hex()}-${hex()}-${hex()}-${hex()}${hex()}${hex()}`;
+}
+
+/**
+ * Get the next version number for a note.
+ */
+export function getNextVersion(db, noteId) {
+  const row = db
+    .prepare(
+      "SELECT MAX(version) as max_ver FROM note_versions WHERE note_id = ?",
+    )
+    .get(noteId);
+  return (row?.max_ver || 0) + 1;
+}
+
+/**
+ * Save a version snapshot of a note.
+ * @param {object} db - Database instance
+ * @param {string} noteId - Note ID
+ * @param {object} noteData - { title, content, tags, category }
+ * @param {string} changeType - 'create' | 'edit' | 'revert'
+ * @returns {object} The saved version record
+ */
+export function saveVersion(db, noteId, noteData, changeType = "edit") {
+  ensureVersionsTable(db);
+  const version = getNextVersion(db, noteId);
+  const id = generateId();
+  const tagsJson =
+    typeof noteData.tags === "string"
+      ? noteData.tags
+      : JSON.stringify(noteData.tags || []);
+
+  db.prepare(
+    "INSERT INTO note_versions (id, note_id, version, title, content, tags, category, change_type) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
+  ).run(
+    id,
+    noteId,
+    version,
+    noteData.title || "",
+    noteData.content || "",
+    tagsJson,
+    noteData.category || "general",
+    changeType,
+  );
+
+  return {
+    id,
+    note_id: noteId,
+    version,
+    title: noteData.title || "",
+    content: noteData.content || "",
+    tags: tagsJson,
+    category: noteData.category || "general",
+    change_type: changeType,
+  };
+}
+
+/**
+ * Get the version history for a note.
+ */
+export function getHistory(db, noteId) {
+  ensureVersionsTable(db);
+  return db
+    .prepare(
+      "SELECT id, note_id, version, title, change_type, created_at FROM note_versions WHERE note_id = ? ORDER BY version DESC",
+    )
+    .all(noteId);
+}
+
+/**
+ * Get a specific version of a note.
+ */
+export function getVersion(db, noteId, version) {
+  ensureVersionsTable(db);
+  return db
+    .prepare("SELECT * FROM note_versions WHERE note_id = ? AND version = ?")
+    .get(noteId, version);
+}
+
+/**
+ * Compute a simple text diff between two strings.
+ * Returns an array of { type: 'add'|'remove'|'same', line } objects.
+ */
+export function simpleDiff(oldText, newText) {
+  const oldLines = (oldText || "").split("\n");
+  const newLines = (newText || "").split("\n");
+  const result = [];
+
+  // Simple line-by-line diff using LCS approach
+  const lcs = computeLcs(oldLines, newLines);
+  let oi = 0;
+  let ni = 0;
+  let li = 0;
+
+  while (oi < oldLines.length || ni < newLines.length) {
+    if (li < lcs.length && oi < oldLines.length && oldLines[oi] === lcs[li]) {
+      if (ni < newLines.length && newLines[ni] === lcs[li]) {
+        result.push({ type: "same", line: lcs[li] });
+        oi++;
+        ni++;
+        li++;
+      } else if (ni < newLines.length) {
+        result.push({ type: "add", line: newLines[ni] });
+        ni++;
+      }
+    } else if (oi < oldLines.length) {
+      if (li < lcs.length && oldLines[oi] !== lcs[li]) {
+        result.push({ type: "remove", line: oldLines[oi] });
+        oi++;
+      } else if (li >= lcs.length) {
+        result.push({ type: "remove", line: oldLines[oi] });
+        oi++;
+      }
+    } else if (ni < newLines.length) {
+      result.push({ type: "add", line: newLines[ni] });
+      ni++;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Compute the Longest Common Subsequence of two string arrays.
+ */
+function computeLcs(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (a[i - 1] === b[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  // Backtrack to get the LCS
+  const result = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    if (a[i - 1] === b[j - 1]) {
+      result.unshift(a[i - 1]);
+      i--;
+      j--;
+    } else if (dp[i - 1][j] > dp[i][j - 1]) {
+      i--;
+    } else {
+      j--;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Format a diff result as a readable string.
+ */
+export function formatDiff(diffResult) {
+  return diffResult
+    .map((d) => {
+      if (d.type === "add") return `+ ${d.line}`;
+      if (d.type === "remove") return `- ${d.line}`;
+      return `  ${d.line}`;
+    })
+    .join("\n");
+}
+
+/**
+ * Revert a note to a specific version.
+ * Saves the current state as a new version first, then applies the old version.
+ */
+export function revertToVersion(db, noteId, version) {
+  ensureVersionsTable(db);
+
+  // Get the target version
+  const targetVersion = getVersion(db, noteId, version);
+  if (!targetVersion) return null;
+
+  // Get current note state
+  const current = db
+    .prepare("SELECT * FROM notes WHERE id = ? AND deleted_at IS NULL")
+    .get(noteId);
+  if (!current) return null;
+
+  // Save current state as a version before reverting
+  saveVersion(db, noteId, current, "edit");
+
+  // Apply the target version to the note
+  db.prepare(
+    "UPDATE notes SET title = ?, content = ?, tags = ?, category = ?, updated_at = datetime('now') WHERE id = ?",
+  ).run(
+    targetVersion.title,
+    targetVersion.content,
+    targetVersion.tags,
+    targetVersion.category,
+    noteId,
+  );
+
+  // Save the revert action as a new version
+  const revertRecord = saveVersion(db, noteId, targetVersion, "revert");
+
+  return {
+    note_id: noteId,
+    reverted_to: version,
+    new_version: revertRecord.version,
+    title: targetVersion.title,
+  };
+}

package/src/lib/org-manager.js

@@ -0,0 +1,424 @@
+/**
+ * Org Manager — Organization, team, and approval workflow management for CLI.
+ * Supports org creation, member management, role assignment, and approval workflows.
+ */
+
+import crypto from "crypto";
+
+/**
+ * Ensure organization tables exist.
+ */
+export function ensureOrgTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS organizations (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      description TEXT,
+      owner_id TEXT NOT NULL,
+      status TEXT DEFAULT 'active',
+      settings TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS org_members (
+      id TEXT PRIMARY KEY,
+      org_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      display_name TEXT,
+      role TEXT DEFAULT 'member',
+      status TEXT DEFAULT 'active',
+      invited_by TEXT,
+      joined_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS org_teams (
+      id TEXT PRIMARY KEY,
+      org_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT,
+      lead_id TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS org_team_members (
+      team_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      role TEXT DEFAULT 'member',
+      added_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS approval_requests (
+      id TEXT PRIMARY KEY,
+      org_id TEXT NOT NULL,
+      requester_id TEXT NOT NULL,
+      approver_id TEXT,
+      request_type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      description TEXT,
+      data TEXT,
+      status TEXT DEFAULT 'pending',
+      decision_note TEXT,
+      created_at TEXT DEFAULT (datetime('now')),
+      decided_at TEXT
+    )
+  `);
+}
+
+// ─── Organization CRUD ──────────────────────────────────
+
+/**
+ * Create an organization.
+ */
+export function createOrg(db, name, ownerId, description) {
+  ensureOrgTables(db);
+  const id = `org-${crypto.randomBytes(8).toString("hex")}`;
+
+  db.prepare(
+    `INSERT INTO organizations (id, name, description, owner_id, status)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(id, name, description || null, ownerId, "active");
+
+  // Add owner as admin member
+  const memberId = `member-${crypto.randomBytes(8).toString("hex")}`;
+  db.prepare(
+    `INSERT INTO org_members (id, org_id, user_id, role, status)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(memberId, id, ownerId, "admin", "active");
+
+  return { id, name, description, ownerId, status: "active" };
+}
+
+/**
+ * Get an organization by ID.
+ */
+export function getOrg(db, orgId) {
+  ensureOrgTables(db);
+  return db.prepare("SELECT * FROM organizations WHERE id = ?").get(orgId);
+}
+
+/**
+ * List all organizations.
+ */
+export function listOrgs(db) {
+  ensureOrgTables(db);
+  return db
+    .prepare("SELECT * FROM organizations ORDER BY created_at DESC")
+    .all();
+}
+
+/**
+ * Update an organization.
+ */
+export function updateOrg(db, orgId, updates) {
+  ensureOrgTables(db);
+  const { name, description, status } = updates;
+  if (name)
+    db.prepare("UPDATE organizations SET name = ? WHERE id = ?").run(
+      name,
+      orgId,
+    );
+  if (description !== undefined)
+    db.prepare("UPDATE organizations SET description = ? WHERE id = ?").run(
+      description,
+      orgId,
+    );
+  if (status)
+    db.prepare("UPDATE organizations SET status = ? WHERE id = ?").run(
+      status,
+      orgId,
+    );
+  return getOrg(db, orgId);
+}
+
+/**
+ * Delete an organization.
+ */
+export function deleteOrg(db, orgId) {
+  ensureOrgTables(db);
+  db.prepare(
+    "DELETE FROM org_team_members WHERE team_id IN (SELECT id FROM org_teams WHERE org_id = ?)",
+  ).run(orgId);
+  db.prepare("DELETE FROM org_teams WHERE org_id = ?").run(orgId);
+  db.prepare("DELETE FROM org_members WHERE org_id = ?").run(orgId);
+  db.prepare("DELETE FROM approval_requests WHERE org_id = ?").run(orgId);
+  const result = db
+    .prepare("DELETE FROM organizations WHERE id = ?")
+    .run(orgId);
+  return result.changes > 0;
+}
+
+// ─── Members ────────────────────────────────────────────
+
+/**
+ * Invite a member to an organization.
+ */
+export function inviteMember(db, orgId, userId, displayName, role, invitedBy) {
+  ensureOrgTables(db);
+  const org = getOrg(db, orgId);
+  if (!org) throw new Error(`Organization not found: ${orgId}`);
+
+  const id = `member-${crypto.randomBytes(8).toString("hex")}`;
+  db.prepare(
+    `INSERT INTO org_members (id, org_id, user_id, display_name, role, status, invited_by)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    orgId,
+    userId,
+    displayName || null,
+    role || "member",
+    "invited",
+    invitedBy || null,
+  );
+
+  return {
+    id,
+    orgId,
+    userId,
+    displayName,
+    role: role || "member",
+    status: "invited",
+  };
+}
+
+/**
+ * Accept an invitation.
+ */
+export function acceptInvite(db, memberId) {
+  ensureOrgTables(db);
+  const result = db
+    .prepare("UPDATE org_members SET status = ? WHERE id = ?")
+    .run("active", memberId);
+  return result.changes > 0;
+}
+
+/**
+ * Get members of an organization.
+ */
+export function getMembers(db, orgId) {
+  ensureOrgTables(db);
+  return db
+    .prepare(
+      "SELECT * FROM org_members WHERE org_id = ? ORDER BY joined_at ASC",
+    )
+    .all(orgId);
+}
+
+/**
+ * Update a member's role.
+ */
+export function updateMemberRole(db, memberId, newRole) {
+  ensureOrgTables(db);
+  const result = db
+    .prepare("UPDATE org_members SET role = ? WHERE id = ?")
+    .run(newRole, memberId);
+  return result.changes > 0;
+}
+
+/**
+ * Remove a member from an organization.
+ */
+export function removeMember(db, memberId) {
+  ensureOrgTables(db);
+  const result = db
+    .prepare("DELETE FROM org_members WHERE id = ?")
+    .run(memberId);
+  return result.changes > 0;
+}
+
+// ─── Teams ──────────────────────────────────────────────
+
+/**
+ * Create a team within an organization.
+ */
+export function createTeam(db, orgId, name, description, leadId) {
+  ensureOrgTables(db);
+  const org = getOrg(db, orgId);
+  if (!org) throw new Error(`Organization not found: ${orgId}`);
+
+  const id = `team-${crypto.randomBytes(8).toString("hex")}`;
+  db.prepare(
+    `INSERT INTO org_teams (id, org_id, name, description, lead_id)
+     VALUES (?, ?, ?, ?, ?)`,
+  ).run(id, orgId, name, description || null, leadId || null);
+
+  return { id, orgId, name, description, leadId };
+}
+
+/**
+ * List teams in an organization.
+ */
+export function listTeams(db, orgId) {
+  ensureOrgTables(db);
+  return db
+    .prepare("SELECT * FROM org_teams WHERE org_id = ? ORDER BY created_at ASC")
+    .all(orgId);
+}
+
+/**
+ * Add a member to a team.
+ */
+export function addTeamMember(db, teamId, userId, role) {
+  ensureOrgTables(db);
+  db.prepare(
+    `INSERT INTO org_team_members (team_id, user_id, role) VALUES (?, ?, ?)`,
+  ).run(teamId, userId, role || "member");
+  return { teamId, userId, role: role || "member" };
+}
+
+/**
+ * Get team members.
+ */
+export function getTeamMembers(db, teamId) {
+  ensureOrgTables(db);
+  return db
+    .prepare("SELECT * FROM org_team_members WHERE team_id = ?")
+    .all(teamId);
+}
+
+/**
+ * Remove a team member.
+ */
+export function removeTeamMember(db, teamId, userId) {
+  ensureOrgTables(db);
+  const result = db
+    .prepare("DELETE FROM org_team_members WHERE team_id = ? AND user_id = ?")
+    .run(teamId, userId);
+  return result.changes > 0;
+}
+
+/**
+ * Delete a team.
+ */
+export function deleteTeam(db, teamId) {
+  ensureOrgTables(db);
+  db.prepare("DELETE FROM org_team_members WHERE team_id = ?").run(teamId);
+  const result = db.prepare("DELETE FROM org_teams WHERE id = ?").run(teamId);
+  return result.changes > 0;
+}
+
+// ─── Approvals ──────────────────────────────────────────
+
+/**
+ * Submit an approval request.
+ */
+export function submitApproval(
+  db,
+  orgId,
+  requesterId,
+  requestType,
+  title,
+  description,
+  data,
+) {
+  ensureOrgTables(db);
+  const id = `approval-${crypto.randomBytes(8).toString("hex")}`;
+
+  db.prepare(
+    `INSERT INTO approval_requests (id, org_id, requester_id, request_type, title, description, data, status)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    id,
+    orgId,
+    requesterId,
+    requestType,
+    title,
+    description || null,
+    data ? JSON.stringify(data) : null,
+    "pending",
+  );
+
+  return { id, orgId, requesterId, requestType, title, status: "pending" };
+}
+
+/**
+ * Approve a request.
+ */
+export function approveRequest(db, approvalId, approverId, note) {
+  ensureOrgTables(db);
+  const result = db
+    .prepare(
+      "UPDATE approval_requests SET status = ?, approver_id = ?, decision_note = ?, decided_at = datetime('now') WHERE id = ?",
+    )
+    .run("approved", approverId, note || null, approvalId);
+  return result.changes > 0;
+}
+
+/**
+ * Reject a request.
+ */
+export function rejectRequest(db, approvalId, approverId, note) {
+  ensureOrgTables(db);
+  const result = db
+    .prepare(
+      "UPDATE approval_requests SET status = ?, approver_id = ?, decision_note = ?, decided_at = datetime('now') WHERE id = ?",
+    )
+    .run("rejected", approverId, note || null, approvalId);
+  return result.changes > 0;
+}
+
+/**
+ * Get approval requests.
+ */
+export function getApprovals(db, options = {}) {
+  ensureOrgTables(db);
+  const { orgId, status, requesterId } = options;
+
+  let sql = "SELECT * FROM approval_requests WHERE 1=1";
+  const params = [];
+
+  if (orgId) {
+    sql += " AND org_id = ?";
+    params.push(orgId);
+  }
+  if (status) {
+    sql += " AND status = ?";
+    params.push(status);
+  }
+  if (requesterId) {
+    sql += " AND requester_id = ?";
+    params.push(requesterId);
+  }
+
+  sql += " ORDER BY created_at DESC";
+  return db.prepare(sql).all(...params);
+}
+
+/**
+ * Get a single approval request.
+ */
+export function getApproval(db, approvalId) {
+  ensureOrgTables(db);
+  return db
+    .prepare("SELECT * FROM approval_requests WHERE id = ?")
+    .get(approvalId);
+}
+
+/**
+ * Get org summary statistics.
+ */
+export function getOrgSummary(db, orgId) {
+  ensureOrgTables(db);
+  const members = db
+    .prepare("SELECT COUNT(*) as c FROM org_members WHERE org_id = ?")
+    .get(orgId);
+  const teams = db
+    .prepare("SELECT COUNT(*) as c FROM org_teams WHERE org_id = ?")
+    .get(orgId);
+  const pending = db
+    .prepare(
+      "SELECT COUNT(*) as c FROM approval_requests WHERE org_id = ? AND status = ?",
+    )
+    .get(orgId, "pending");
+
+  return {
+    memberCount: members?.c || 0,
+    teamCount: teams?.c || 0,
+    pendingApprovals: pending?.c || 0,
+  };
+}