codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/mobile-budget.js

@@ -0,0 +1,98 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_budget_exports = {};
+__export(mobile_budget_exports, {
+  BUDGET_METHODS: () => BUDGET_METHODS,
+  handleBudgetMethod: () => handleBudgetMethod,
+  phoneBudget: () => phoneBudget
+});
+module.exports = __toCommonJS(mobile_budget_exports);
+var budgetService = __toESM(require("./budget-service"));
+var import_plan_service = require("./plan-service");
+var import_settings_service = require("./settings-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_capabilities = require("./peer-capabilities");
+var import_peer_audit_service = require("./peer-audit-service");
+var import_budget_words = require("../../shared/lib/budget-words");
+const BUDGET_METHODS = ["budget.get", "budget.acknowledge"];
+async function handleBudgetMethod(method, params, peer) {
+  switch (method) {
+    case "budget.get":
+      return phoneBudget(requirePlan(params));
+    case "budget.acknowledge":
+      return acknowledge(requirePlan(params), params.changeId, peer);
+    default:
+      throw new Error(`Unknown budget method: ${method}`);
+  }
+}
+function requirePlan(params) {
+  const planUid = params.planUid;
+  if (typeof planUid !== "string" || !planUid) throw new Error("planUid is required");
+  if (!(0, import_plan_service.getPlan)(planUid)) throw new Error("Plan not found");
+  return planUid;
+}
+function phoneBudget(planUid) {
+  const report = budgetService.getBudgetReport(planUid);
+  return {
+    planUid,
+    budget: report.budget ? { minutes: report.budget.minutes, costUsd: report.budget.costUsd, exempt: report.budget.exempt } : null,
+    spentMinutes: report.spentMinutes,
+    spentCostUsd: report.spentCostUsd,
+    flaggedChanges: report.flaggedChanges.map((c) => ({
+      id: c.id,
+      by: c.actor,
+      byType: c.actorType,
+      words: (0, import_budget_words.describeBudgetChange)(c.before, c.after),
+      at: c.at
+    }))
+  };
+}
+function acknowledge(planUid, changeId, peer) {
+  if (typeof changeId !== "number" || !Number.isInteger(changeId)) throw new Error("changeId must be a number");
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) {
+    throw new import_peer_capabilities.PeerAuthorizationError("Marking a budget change seen needs a pairing confirmed on the desktop");
+  }
+  const change = budgetService.acknowledgeBudgetChange(planUid, changeId, (0, import_settings_service.getAuthorKey)("human"));
+  if (!change) throw new Error("No such budget change on this plan");
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind: "decision",
+    fingerprint: peer.fingerprint,
+    alias: device.alias,
+    method: "budget.acknowledge",
+    detail: `saw budget change ${changeId} on plan ${planUid}`
+  });
+  peer.broadcast?.("plan-budget-changed", { planUid, acknowledged: changeId });
+  return phoneBudget(planUid);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUDGET_METHODS,
+  handleBudgetMethod,
+  phoneBudget
+});

package/src/backend/services/mobile-freeze.js

@@ -0,0 +1,106 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_freeze_exports = {};
+__export(mobile_freeze_exports, {
+  FREEZE_METHODS: () => FREEZE_METHODS,
+  handleFreezeMethod: () => handleFreezeMethod,
+  phoneFreeze: () => phoneFreeze
+});
+module.exports = __toCommonJS(mobile_freeze_exports);
+var freezeService = __toESM(require("./freeze-service"));
+var import_plan_service = require("./plan-service");
+var import_settings_service = require("./settings-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_capabilities = require("./peer-capabilities");
+var import_peer_audit_service = require("./peer-audit-service");
+var import_trusted_roots = require("./trusted-roots");
+var import_freeze_words = require("../../shared/lib/freeze-words");
+const FREEZE_METHODS = ["freeze.get", "freeze.acknowledge"];
+async function handleFreezeMethod(method, params, peer) {
+  switch (method) {
+    case "freeze.get":
+      return phoneFreeze(requirePlan(params));
+    case "freeze.acknowledge":
+      return acknowledge(requirePlan(params), params.changeId, peer);
+    default:
+      throw new Error(`Unknown freeze method: ${method}`);
+  }
+}
+function requirePlan(params) {
+  const planUid = params.planUid;
+  if (typeof planUid !== "string" || !planUid) throw new Error("planUid is required");
+  if (!(0, import_plan_service.getPlan)(planUid)) throw new Error("Plan not found");
+  return planUid;
+}
+function projectOf(planUid) {
+  const plan = (0, import_plan_service.getPlan)(planUid);
+  if (!plan?.projectPath) throw new Error("This plan is not in a project");
+  return (0, import_trusted_roots.resolveTrustedProjectRoot)(plan.projectPath, "plan.projectPath");
+}
+function phoneFreeze(planUid) {
+  const status = freezeService.getFreezeStatus(projectOf(planUid));
+  return {
+    planUid,
+    active: status.active,
+    reason: status.reason,
+    until: status.until,
+    planExempt: status.allowedPlanUids.includes(planUid),
+    flaggedChanges: status.flaggedChanges.map((c) => ({
+      id: c.id,
+      by: c.actor,
+      byType: c.actorType,
+      words: (0, import_freeze_words.describeFreezeChange)(c.before, c.after),
+      at: c.at
+    }))
+  };
+}
+function acknowledge(planUid, changeId, peer) {
+  if (typeof changeId !== "number" || !Number.isInteger(changeId)) throw new Error("changeId must be a number");
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) {
+    throw new import_peer_capabilities.PeerAuthorizationError("Marking a freeze change seen needs a pairing confirmed on the desktop");
+  }
+  const projectPath = projectOf(planUid);
+  const change = freezeService.acknowledgeFreezeChange(projectPath, changeId, (0, import_settings_service.getAuthorKey)("human"));
+  if (!change) throw new Error("No such freeze change on this project");
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind: "decision",
+    fingerprint: peer.fingerprint,
+    alias: device.alias,
+    method: "freeze.acknowledge",
+    detail: `saw freeze change ${changeId} on ${projectPath}`
+  });
+  peer.broadcast?.("freeze-changed", { projectRoot: projectPath, acknowledged: changeId });
+  return phoneFreeze(planUid);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FREEZE_METHODS,
+  handleFreezeMethod,
+  phoneFreeze
+});

package/src/backend/services/mobile-proposals.js

@@ -0,0 +1,100 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mobile_proposals_exports = {};
+__export(mobile_proposals_exports, {
+  PROPOSAL_METHODS: () => PROPOSAL_METHODS,
+  handleProposalMethod: () => handleProposalMethod,
+  toPhoneProposal: () => toPhoneProposal
+});
+module.exports = __toCommonJS(mobile_proposals_exports);
+var import_spec_proposals_service = require("./spec-proposals-service");
+var import_paired_device_service = require("./paired-device-service");
+var import_peer_capabilities = require("./peer-capabilities");
+var import_peer_audit_service = require("./peer-audit-service");
+var import_proposal_words = require("../../shared/lib/proposal-words");
+const PROPOSAL_METHODS = ["proposal.list", "proposal.get", "proposal.decide"];
+async function handleProposalMethod(method, params, peer, ctx) {
+  switch (method) {
+    case "proposal.list":
+      return { proposals: (0, import_spec_proposals_service.listProposals)({ status: "open", ...ctx.projectRoot ? { projectPath: ctx.projectRoot } : {} }).reverse().map(toPhoneProposal) };
+    case "proposal.get": {
+      const p = typeof params.uid === "string" ? (0, import_spec_proposals_service.getProposal)(params.uid) : null;
+      if (!p) throw new Error("No such proposal");
+      return { proposal: toPhoneProposal(p) };
+    }
+    case "proposal.decide":
+      return decide(params, peer, ctx);
+    default:
+      throw new Error(`Unknown proposal method: ${method}`);
+  }
+}
+function toPhoneProposal(p) {
+  return {
+    uid: p.uid,
+    hitRef: p.hitRef,
+    status: p.status,
+    headline: (0, import_proposal_words.proposalHeadline)(p),
+    where: (0, import_proposal_words.proposalWhere)(p),
+    why: p.why,
+    evidence: (0, import_proposal_words.evidenceWords)(p.evidence),
+    before: p.beforeText,
+    proposed: p.proposedText,
+    replies: (0, import_proposal_words.repliesLine)(p),
+    impacts: p.impacts.map((i) => ({ impact: i.impact, label: (0, import_proposal_words.impactLabel)(i), who: (0, import_proposal_words.impactWho)(i), words: i.words })),
+    pageChangedSince: p.pageChangedSince,
+    guardNote: p.pageBreakpoint?.note ?? null,
+    guarded: !!p.pageBreakpoint,
+    createdAt: p.createdAt,
+    decidedAt: p.decidedAt,
+    decisionNote: p.decisionNote
+  };
+}
+function decide(params, peer, ctx) {
+  const uid = params.uid;
+  if (typeof uid !== "string" || !uid) throw new Error("uid is required");
+  const decision = params.decision;
+  if (decision !== "accept" && decision !== "reject") throw new Error("On the phone a proposal is accepted or rejected; amending it is done in the window.");
+  const device = (0, import_paired_device_service.getPairedDevice)(peer.fingerprint);
+  if (!device?.confirmedAt) {
+    throw new import_peer_capabilities.PeerAuthorizationError("Deciding a spec change needs a pairing confirmed on the desktop");
+  }
+  const existing = (0, import_spec_proposals_service.getProposal)(uid);
+  if (!existing) throw new Error("No such proposal");
+  if (existing.status !== "open") return { proposal: toPhoneProposal(existing), alreadyDecided: true };
+  const input = { uid, decision, note: typeof params.note === "string" ? params.note : void 0 };
+  const problem = (0, import_spec_proposals_service.decisionProblem)(input);
+  if (problem) throw new Error(problem);
+  const { proposal, flagged } = (0, import_spec_proposals_service.decideProposal)(input, ctx.who);
+  (0, import_peer_audit_service.recordPeerAudit)({
+    kind: "decision",
+    fingerprint: peer.fingerprint,
+    alias: device.alias,
+    method: "proposal.decide",
+    detail: `${decision} on spec proposal ${uid}`
+  });
+  peer.broadcast?.("spec-proposal-decided", { uid: proposal.uid, status: proposal.status, pageUid: proposal.pageUid });
+  if (proposal.hitRef) peer.broadcast?.("breakpoint-answered", { ref: proposal.hitRef, planUid: proposal.planUid, decision: proposal.status === "rejected" ? "stop" : "continue" });
+  if (proposal.status === "accepted") peer.broadcast?.("plan-item-updated", { planUid: proposal.planUid, itemUid: proposal.pageUid, kind: "object", changes: { body: true } });
+  return { proposal: toPhoneProposal(proposal), flagged: flagged.length };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PROPOSAL_METHODS,
+  handleProposalMethod,
+  toPhoneProposal
+});