chainlesschain 0.37.9 → 0.37.11

package/src/commands/note.js

@@ -6,6 +6,15 @@
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  ensureVersionsTable,
+  saveVersion,
+  getHistory,
+  getVersion,
+  simpleDiff,
+  formatDiff,
+  revertToVersion,
+} from "../lib/note-versioning.js";
 
 /**
  * Ensure the notes table exists in the database
@@ -299,4 +308,182 @@ export function registerNoteCommand(program) {
         process.exit(1);
       }
     });
+
+  // note history
+  note
+    .command("history")
+    .description("Show version history for a note")
+    .argument("<id>", "Note ID (or prefix)")
+    .option("--json", "Output as JSON")
+    .action(async (id, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const rawDb = ctx.db.getDatabase();
+        ensureNotesTable(rawDb);
+        ensureVersionsTable(rawDb);
+
+        // Find the note
+        const noteRow = rawDb
+          .prepare(
+            "SELECT id FROM notes WHERE id LIKE ? AND deleted_at IS NULL",
+          )
+          .get(`${id}%`);
+
+        if (!noteRow) {
+          logger.error(`Note not found: ${id}`);
+          process.exit(1);
+        }
+
+        const history = getHistory(rawDb, noteRow.id);
+
+        if (options.json) {
+          console.log(JSON.stringify(history, null, 2));
+        } else if (history.length === 0) {
+          logger.info("No version history found");
+        } else {
+          logger.log(
+            chalk.bold(`Version history (${history.length} versions):\n`),
+          );
+          for (const v of history) {
+            logger.log(
+              `  ${chalk.cyan(`v${v.version}`)}  ${chalk.white(v.title)}  ${chalk.gray(v.change_type)}  ${chalk.gray(v.created_at || "")}`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed to get history: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // note diff
+  note
+    .command("diff")
+    .description("Show diff between two versions of a note")
+    .argument("<id>", "Note ID (or prefix)")
+    .argument("<v1>", "First version number")
+    .argument("<v2>", "Second version number")
+    .option("--json", "Output as JSON")
+    .action(async (id, v1, v2, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const rawDb = ctx.db.getDatabase();
+        ensureNotesTable(rawDb);
+        ensureVersionsTable(rawDb);
+
+        const noteRow = rawDb
+          .prepare(
+            "SELECT id FROM notes WHERE id LIKE ? AND deleted_at IS NULL",
+          )
+          .get(`${id}%`);
+
+        if (!noteRow) {
+          logger.error(`Note not found: ${id}`);
+          process.exit(1);
+        }
+
+        const ver1 = getVersion(rawDb, noteRow.id, parseInt(v1));
+        const ver2 = getVersion(rawDb, noteRow.id, parseInt(v2));
+
+        if (!ver1) {
+          logger.error(`Version ${v1} not found`);
+          process.exit(1);
+        }
+        if (!ver2) {
+          logger.error(`Version ${v2} not found`);
+          process.exit(1);
+        }
+
+        const diff = simpleDiff(ver1.content, ver2.content);
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { v1: parseInt(v1), v2: parseInt(v2), diff },
+              null,
+              2,
+            ),
+          );
+        } else {
+          logger.log(chalk.bold(`Diff: v${v1} → v${v2}\n`));
+          logger.log(formatDiff(diff));
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed to compute diff: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // note revert
+  note
+    .command("revert")
+    .description("Revert a note to a specific version")
+    .argument("<id>", "Note ID (or prefix)")
+    .argument("<version>", "Version number to revert to")
+    .option("--force", "Skip confirmation")
+    .action(async (id, version, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+
+        const rawDb = ctx.db.getDatabase();
+        ensureNotesTable(rawDb);
+        ensureVersionsTable(rawDb);
+
+        const noteRow = rawDb
+          .prepare(
+            "SELECT id, title FROM notes WHERE id LIKE ? AND deleted_at IS NULL",
+          )
+          .get(`${id}%`);
+
+        if (!noteRow) {
+          logger.error(`Note not found: ${id}`);
+          process.exit(1);
+        }
+
+        if (!options.force) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: `Revert note "${noteRow.title}" to version ${version}?`,
+          });
+          if (!ok) {
+            logger.info("Cancelled");
+            return;
+          }
+        }
+
+        const result = revertToVersion(rawDb, noteRow.id, parseInt(version));
+
+        if (!result) {
+          logger.error(`Version ${version} not found or note unavailable`);
+          process.exit(1);
+        }
+
+        logger.success(
+          `Note reverted to v${result.reverted_to} → new version v${result.new_version}`,
+        );
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed to revert: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

package/src/commands/org.js

@@ -0,0 +1,505 @@
+/**
+ * Organization & team commands
+ * chainlesschain org create|list|show|update|delete|invite|members|team|approval
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import {
+  createOrg,
+  getOrg,
+  listOrgs,
+  updateOrg,
+  deleteOrg,
+  inviteMember,
+  acceptInvite,
+  getMembers,
+  updateMemberRole,
+  removeMember,
+  createTeam,
+  listTeams,
+  addTeamMember,
+  getTeamMembers,
+  removeTeamMember,
+  deleteTeam,
+  submitApproval,
+  approveRequest,
+  rejectRequest,
+  getApprovals,
+  getOrgSummary,
+} from "../lib/org-manager.js";
+
+export function registerOrgCommand(program) {
+  const org = program
+    .command("org")
+    .description("Organization, team, and approval management");
+
+  // org create
+  org
+    .command("create")
+    .description("Create a new organization")
+    .argument("<name>", "Organization name")
+    .option("--owner <id>", "Owner user ID", "cli-user")
+    .option("--description <desc>", "Organization description")
+    .option("--json", "Output as JSON")
+    .action(async (name, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const result = createOrg(db, name, options.owner, options.description);
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success("Organization created");
+          logger.log(`  ${chalk.bold("ID:")}    ${chalk.cyan(result.id)}`);
+          logger.log(`  ${chalk.bold("Name:")}  ${result.name}`);
+          logger.log(`  ${chalk.bold("Owner:")} ${result.ownerId}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org list
+  org
+    .command("list", { isDefault: true })
+    .description("List all organizations")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const orgs = listOrgs(db);
+
+        if (options.json) {
+          console.log(JSON.stringify(orgs, null, 2));
+        } else if (orgs.length === 0) {
+          logger.info(
+            'No organizations. Create one with "chainlesschain org create <name>"',
+          );
+        } else {
+          logger.log(chalk.bold(`Organizations (${orgs.length}):\n`));
+          for (const o of orgs) {
+            const status =
+              o.status === "active"
+                ? chalk.green("active")
+                : chalk.gray(o.status);
+            logger.log(`  ${chalk.cyan(o.id)} - ${o.name} [${status}]`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org show
+  org
+    .command("show")
+    .description("Show organization details")
+    .argument("<org-id>", "Organization ID")
+    .option("--json", "Output as JSON")
+    .action(async (orgId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const orgData = getOrg(db, orgId);
+
+        if (!orgData) {
+          logger.error(`Organization not found: ${orgId}`);
+          process.exit(1);
+        }
+
+        const summary = getOrgSummary(db, orgId);
+
+        if (options.json) {
+          console.log(JSON.stringify({ ...orgData, ...summary }, null, 2));
+        } else {
+          logger.log(chalk.bold("Organization:\n"));
+          logger.log(
+            `  ${chalk.bold("ID:")}          ${chalk.cyan(orgData.id)}`,
+          );
+          logger.log(`  ${chalk.bold("Name:")}        ${orgData.name}`);
+          logger.log(
+            `  ${chalk.bold("Description:")} ${orgData.description || chalk.gray("(none)")}`,
+          );
+          logger.log(`  ${chalk.bold("Owner:")}       ${orgData.owner_id}`);
+          logger.log(`  ${chalk.bold("Members:")}     ${summary.memberCount}`);
+          logger.log(`  ${chalk.bold("Teams:")}       ${summary.teamCount}`);
+          logger.log(
+            `  ${chalk.bold("Pending:")}     ${summary.pendingApprovals}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org delete
+  org
+    .command("delete")
+    .description("Delete an organization")
+    .argument("<org-id>", "Organization ID")
+    .option("--force", "Skip confirmation")
+    .action(async (orgId, options) => {
+      try {
+        if (!options.force) {
+          const { confirm } = await import("@inquirer/prompts");
+          const ok = await confirm({
+            message: "Delete this organization and all its data?",
+          });
+          if (!ok) {
+            logger.info("Cancelled");
+            return;
+          }
+        }
+
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = deleteOrg(db, orgId);
+
+        if (ok) {
+          logger.success("Organization deleted");
+        } else {
+          logger.error(`Organization not found: ${orgId}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org invite
+  org
+    .command("invite")
+    .description("Invite a member to an organization")
+    .argument("<org-id>", "Organization ID")
+    .argument("<user-id>", "User ID to invite")
+    .option("--name <name>", "Display name")
+    .option("--role <role>", "Role (admin/member/viewer)", "member")
+    .action(async (orgId, userId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const result = inviteMember(
+          db,
+          orgId,
+          userId,
+          options.name,
+          options.role,
+        );
+        logger.success(`Invited ${userId} as ${result.role}`);
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org members
+  org
+    .command("members")
+    .description("List organization members")
+    .argument("<org-id>", "Organization ID")
+    .option("--json", "Output as JSON")
+    .action(async (orgId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const members = getMembers(db, orgId);
+
+        if (options.json) {
+          console.log(JSON.stringify(members, null, 2));
+        } else if (members.length === 0) {
+          logger.info("No members");
+        } else {
+          logger.log(chalk.bold(`Members (${members.length}):\n`));
+          for (const m of members) {
+            const role =
+              m.role === "admin" ? chalk.yellow(m.role) : chalk.gray(m.role);
+            const status =
+              m.status === "active"
+                ? chalk.green("active")
+                : chalk.gray(m.status);
+            logger.log(`  ${m.user_id} [${role}] ${status}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org team create
+  org
+    .command("team-create")
+    .description("Create a team")
+    .argument("<org-id>", "Organization ID")
+    .argument("<team-name>", "Team name")
+    .option("--description <desc>", "Team description")
+    .option("--lead <id>", "Team lead user ID")
+    .option("--json", "Output as JSON")
+    .action(async (orgId, teamName, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const team = createTeam(
+          db,
+          orgId,
+          teamName,
+          options.description,
+          options.lead,
+        );
+
+        if (options.json) {
+          console.log(JSON.stringify(team, null, 2));
+        } else {
+          logger.success("Team created");
+          logger.log(`  ${chalk.bold("ID:")}   ${chalk.cyan(team.id)}`);
+          logger.log(`  ${chalk.bold("Name:")} ${team.name}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org teams
+  org
+    .command("teams")
+    .description("List teams in an organization")
+    .argument("<org-id>", "Organization ID")
+    .option("--json", "Output as JSON")
+    .action(async (orgId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const teams = listTeams(db, orgId);
+
+        if (options.json) {
+          console.log(JSON.stringify(teams, null, 2));
+        } else if (teams.length === 0) {
+          logger.info("No teams");
+        } else {
+          logger.log(chalk.bold(`Teams (${teams.length}):\n`));
+          for (const t of teams) {
+            logger.log(`  ${chalk.cyan(t.id)} - ${t.name}`);
+            if (t.description) logger.log(`    ${chalk.gray(t.description)}`);
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org approval submit
+  org
+    .command("approval-submit")
+    .description("Submit an approval request")
+    .argument("<org-id>", "Organization ID")
+    .argument("<title>", "Request title")
+    .option("--type <type>", "Request type", "general")
+    .option("--description <desc>", "Request description")
+    .option("--requester <id>", "Requester ID", "cli-user")
+    .option("--json", "Output as JSON")
+    .action(async (orgId, title, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const result = submitApproval(
+          db,
+          orgId,
+          options.requester,
+          options.type,
+          title,
+          options.description,
+        );
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success("Approval request submitted");
+          logger.log(`  ${chalk.bold("ID:")}     ${chalk.cyan(result.id)}`);
+          logger.log(
+            `  ${chalk.bold("Status:")} ${chalk.yellow(result.status)}`,
+          );
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org approval list
+  org
+    .command("approvals")
+    .description("List approval requests")
+    .option("--org <id>", "Filter by organization")
+    .option("--status <status>", "Filter by status (pending/approved/rejected)")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const approvals = getApprovals(db, {
+          orgId: options.org,
+          status: options.status,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(approvals, null, 2));
+        } else if (approvals.length === 0) {
+          logger.info("No approval requests");
+        } else {
+          logger.log(chalk.bold(`Approvals (${approvals.length}):\n`));
+          for (const a of approvals) {
+            const statusColor =
+              a.status === "approved"
+                ? chalk.green
+                : a.status === "rejected"
+                  ? chalk.red
+                  : chalk.yellow;
+            logger.log(
+              `  ${chalk.cyan(a.id)} ${a.title} [${statusColor(a.status)}]`,
+            );
+          }
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org approval approve
+  org
+    .command("approve")
+    .description("Approve a request")
+    .argument("<approval-id>", "Approval request ID")
+    .option("--approver <id>", "Approver ID", "cli-user")
+    .option("--note <note>", "Decision note")
+    .action(async (approvalId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = approveRequest(
+          db,
+          approvalId,
+          options.approver,
+          options.note,
+        );
+
+        if (ok) {
+          logger.success("Request approved");
+        } else {
+          logger.error(`Request not found: ${approvalId}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // org approval reject
+  org
+    .command("reject")
+    .description("Reject a request")
+    .argument("<approval-id>", "Approval request ID")
+    .option("--approver <id>", "Approver ID", "cli-user")
+    .option("--note <note>", "Decision note")
+    .action(async (approvalId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        const ok = rejectRequest(
+          db,
+          approvalId,
+          options.approver,
+          options.note,
+        );
+
+        if (ok) {
+          logger.success("Request rejected");
+        } else {
+          logger.error(`Request not found: ${approvalId}`);
+        }
+
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}