dxcomplete 0.1.0

package/dist/runtime/config.js

@@ -0,0 +1,93 @@
+import { constants as fsConstants } from "node:fs";
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+export class RuntimeConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "RuntimeConfigError";
+    }
+}
+const DEFAULT_ENV_FILE = ".env.local";
+const DEFAULT_DATABASE_NAME = "dxcomplete";
+export async function loadRuntimeConfig(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const envFilePath = await resolveEnvFile(cwd, options.envFile);
+    const fileEnv = envFilePath ? await parseEnvFile(envFilePath) : {};
+    const env = {
+        ...fileEnv,
+        ...(options.env ?? process.env)
+    };
+    const mongodbUri = readRequiredEnv(env, "DXC_MONGODB_URI");
+    const databaseName = readOptionalEnv(env, "DXC_DATABASE_NAME") ?? DEFAULT_DATABASE_NAME;
+    const googleClientId = readOptionalEnv(env, "DXC_GOOGLE_CLIENT_ID");
+    const googleClientSecret = readOptionalEnv(env, "DXC_GOOGLE_CLIENT_SECRET");
+    const serviceProvisioningSecret = readOptionalEnv(env, "DXC_SERVICE_PROVISIONING_SECRET");
+    return {
+        mongodbUri,
+        databaseName,
+        ...(googleClientId ? { googleClientId } : {}),
+        ...(googleClientSecret ? { googleClientSecret } : {}),
+        ...(serviceProvisioningSecret ? { serviceProvisioningSecret } : {}),
+        envFilePath
+    };
+}
+async function resolveEnvFile(cwd, envFile) {
+    if (envFile) {
+        const explicitPath = path.resolve(cwd, envFile);
+        if (!(await fileExists(explicitPath))) {
+            throw new RuntimeConfigError(`Env file not found: ${explicitPath}`);
+        }
+        return explicitPath;
+    }
+    const defaultPath = path.join(cwd, DEFAULT_ENV_FILE);
+    return (await fileExists(defaultPath)) ? defaultPath : undefined;
+}
+async function parseEnvFile(filePath) {
+    const content = await readFile(filePath, "utf8");
+    const parsed = {};
+    for (const [index, rawLine] of content.split(/\r?\n/).entries()) {
+        const trimmed = rawLine.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        const line = trimmed.startsWith("export ") ? trimmed.slice("export ".length).trim() : trimmed;
+        const equalsIndex = line.indexOf("=");
+        if (equalsIndex === -1) {
+            throw new RuntimeConfigError(`Invalid env line ${index + 1} in ${filePath}. Expected KEY=value.`);
+        }
+        const key = line.slice(0, equalsIndex).trim();
+        const value = line.slice(equalsIndex + 1).trim();
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+            throw new RuntimeConfigError(`Invalid env key "${key}" on line ${index + 1} in ${filePath}.`);
+        }
+        parsed[key] = unquote(value);
+    }
+    return parsed;
+}
+function readRequiredEnv(env, key) {
+    const value = readOptionalEnv(env, key);
+    if (!value) {
+        throw new RuntimeConfigError(`${key} is required. Create .env.local from .env.example or export ${key} before running this command.`);
+    }
+    return value;
+}
+function readOptionalEnv(env, key) {
+    const value = env[key]?.trim();
+    return value ? value : undefined;
+}
+function unquote(value) {
+    if ((value.startsWith("\"") && value.endsWith("\"")) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+async function fileExists(filePath) {
+    try {
+        await access(filePath, fsConstants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/runtime/mongo.d.ts

@@ -0,0 +1,9 @@
+import { MongoClient, type Db } from "mongodb";
+import { type RuntimeConfig, type RuntimeOptions } from "./config.js";
+export type DxRuntime = {
+    config: RuntimeConfig;
+    client: MongoClient;
+    db: Db;
+    close: () => Promise<void>;
+};
+export declare function connectRuntime(options?: RuntimeOptions): Promise<DxRuntime>;

package/dist/runtime/mongo.js

@@ -0,0 +1,56 @@
+import { MongoClient } from "mongodb";
+import { OAUTH_AUTH_REQUESTS_COLLECTION, OAUTH_CLIENTS_COLLECTION, OAUTH_CODES_COLLECTION, OAUTH_TOKENS_COLLECTION, WORKSPACE_SERVICE_CLIENTS_COLLECTION, WORKSPACE_MEMBERSHIPS_COLLECTION } from "./auth.js";
+import { loadRuntimeConfig } from "./config.js";
+import { DXCOMPLETE_TICKET_COLLECTION_NAME, INDEX_COLLECTION_NAMES, READABLE_ID_COLLECTION_NAMES, READABLE_ID_SEQUENCES_COLLECTION, migrateLegacyIntakeItemsToDxcompleteTickets } from "./records.js";
+export async function connectRuntime(options = {}) {
+    const config = await loadRuntimeConfig(options);
+    const client = new MongoClient(config.mongodbUri, {
+        serverSelectionTimeoutMS: 10000
+    });
+    await client.connect();
+    const db = client.db(config.databaseName);
+    await db.command({ ping: 1 });
+    await migrateLegacyIntakeItemsToDxcompleteTickets(db);
+    await ensureIndexes(db);
+    return {
+        config,
+        client,
+        db,
+        close: () => client.close()
+    };
+}
+async function ensureIndexes(db) {
+    await Promise.all(INDEX_COLLECTION_NAMES.map(async (collectionName) => {
+        const collection = db.collection(collectionName);
+        await collection.createIndex({ recordType: 1, createdAt: -1 });
+        await collection.createIndex({ workspaceId: 1, recordType: 1, createdAt: -1 });
+        await collection.createIndex({ "links.toId": 1 });
+        await collection.createIndex({ workspaceId: 1, "links.toId": 1 });
+        if (READABLE_ID_COLLECTION_NAMES.includes(collectionName)) {
+            await collection.createIndex({ workspaceId: 1, readableId: 1 }, {
+                unique: true,
+                partialFilterExpression: { readableId: { $exists: true } }
+            });
+        }
+        if (collectionName === DXCOMPLETE_TICKET_COLLECTION_NAME) {
+            await collection.createIndex({ "fields.ownerActorId": 1, archivedAt: 1, updatedAt: -1 });
+            await collection.createIndex({ "fields.entries.addressedToActorId": 1, "fields.entries.readAt": 1 });
+        }
+        if (collectionName === "journal_entries") {
+            await collection.createIndex({ workspaceId: 1, "fields.kind": 1, archivedAt: 1, createdAt: 1 });
+            await collection.createIndex({ workspaceId: 1, archivedAt: 1, createdAt: 1 });
+        }
+    }));
+    await Promise.all([
+        db.collection(WORKSPACE_MEMBERSHIPS_COLLECTION).createIndex({ workspaceId: 1, email: 1 }, { unique: true }),
+        db.collection(WORKSPACE_MEMBERSHIPS_COLLECTION).createIndex({ provider: 1, providerSubject: 1 }),
+        db.collection(WORKSPACE_SERVICE_CLIENTS_COLLECTION).createIndex({ workspaceId: 1, clientId: 1 }, { unique: true }),
+        db.collection(WORKSPACE_SERVICE_CLIENTS_COLLECTION).createIndex({ clientId: 1 }, { unique: true }),
+        db.collection(OAUTH_CLIENTS_COLLECTION).createIndex({ clientId: 1 }, { unique: true }),
+        db.collection(OAUTH_AUTH_REQUESTS_COLLECTION).createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 }),
+        db.collection(OAUTH_CODES_COLLECTION).createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 }),
+        db.collection(OAUTH_TOKENS_COLLECTION).createIndex({ expiresAt: 1 }, { expireAfterSeconds: 0 }),
+        db.collection(OAUTH_TOKENS_COLLECTION).createIndex({ workspaceId: 1, "actor.actorId": 1 }),
+        db.collection(READABLE_ID_SEQUENCES_COLLECTION).createIndex({ workspaceId: 1, recordType: 1 }, { unique: true })
+    ]);
+}

package/dist/runtime/records.d.ts

@@ -0,0 +1,336 @@
+import type { Db } from "mongodb";
+import type { ActorContext } from "./actor.js";
+export declare const COLLECTION_NAMES: readonly ["workspaces", "statements", "journal_entries", "environments", "components", "estimates", "benefits", "expectations", "requirements", "tasks", "commitments", "deferrals", "changes", "decisions", "risks"];
+export declare const LEGACY_COLLECTION_NAMES: readonly ["engagements", "initiatives", "service_charters", "cost_baselines", "cost_actuals", "benefit_measurements"];
+export declare const DXCOMPLETE_TICKET_COLLECTION_NAME = "dxcomplete_tickets";
+export declare const LEGACY_INTAKE_COLLECTION_NAME = "intake_items";
+export declare const LEGACY_PRIVATE_COLLECTION_NAMES: readonly ["intake_items"];
+export declare const INDEX_COLLECTION_NAMES: readonly ["workspaces", "statements", "journal_entries", "environments", "components", "estimates", "benefits", "expectations", "requirements", "tasks", "commitments", "deferrals", "changes", "decisions", "risks", "dxcomplete_tickets"];
+export declare const LINK_SCAN_COLLECTION_NAMES: readonly ["workspaces", "statements", "journal_entries", "environments", "components", "estimates", "benefits", "expectations", "requirements", "tasks", "commitments", "deferrals", "changes", "decisions", "risks", "engagements", "initiatives", "service_charters", "cost_baselines", "cost_actuals", "benefit_measurements"];
+export declare const READABLE_ID_SEQUENCES_COLLECTION = "readable_id_sequences";
+export declare const READABLE_ID_TYPE_CODES: {
+    readonly statements: "STM";
+    readonly journal_entries: "JRN";
+    readonly environments: "ENV";
+    readonly components: "CMP";
+    readonly expectations: "EXP";
+    readonly requirements: "REQ";
+    readonly tasks: "TSK";
+    readonly commitments: "CMT";
+    readonly deferrals: "DFR";
+    readonly decisions: "DEC";
+    readonly changes: "CHG";
+    readonly risks: "RSK";
+    readonly estimates: "EST";
+    readonly benefits: "BFT";
+};
+export declare const READABLE_ID_COLLECTION_NAMES: ReadableIdCollectionName[];
+export type CollectionName = (typeof COLLECTION_NAMES)[number];
+export type ReadableIdCollectionName = keyof typeof READABLE_ID_TYPE_CODES;
+export type PrivateCollectionName = typeof DXCOMPLETE_TICKET_COLLECTION_NAME;
+export type RuntimeCollectionName = CollectionName | PrivateCollectionName | (typeof LEGACY_COLLECTION_NAMES)[number] | (typeof LEGACY_PRIVATE_COLLECTION_NAMES)[number];
+export type RecordLink = {
+    toType: RuntimeCollectionName;
+    toId: string;
+    relationship: string;
+    createdAt: string;
+    createdBy: string;
+};
+export type RecordEdge = RecordLink & {
+    fromType: RuntimeCollectionName;
+    fromId: string;
+};
+export type DxcRecord = {
+    _id: string;
+    recordType: RuntimeCollectionName;
+    readableId?: string;
+    workspaceId?: string;
+    title?: string;
+    summary?: string;
+    fields: Record<string, unknown>;
+    links: RecordLink[];
+    archivedAt?: string;
+    archivedBy?: string;
+    archiveReason?: string;
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    updatedBy: string;
+};
+export type ReviewableRecordType = "expectations" | "requirements";
+export type ReviewNote = {
+    id: string;
+    body: string;
+    createdAt: string;
+    createdBy: string;
+    important?: true;
+};
+export type RecordVersionSnapshot = {
+    title?: string;
+    summary?: string;
+    fields: Record<string, unknown>;
+};
+export type RecordVersionHistoryEntry = {
+    id: string;
+    fromVersion: number;
+    toVersion: number;
+    createdAt: string;
+    createdBy: string;
+    changedFields: string[];
+    previousSnapshot: RecordVersionSnapshot;
+    nextSnapshot: RecordVersionSnapshot;
+    revisionNote?: string;
+};
+export type ChangeEventType = "notice_given" | "veto_recorded" | "emergency_declared" | "decision_recorded" | "result_reported" | "recovery_recorded" | "plan_revised" | "note_added";
+export type ChangeEvent = {
+    id: string;
+    eventType: ChangeEventType;
+    createdAt: string;
+    createdBy: string;
+} & Record<string, unknown>;
+export type DeferralEventType = "condition_addressed" | "condition_reopened" | "condition_note_added" | "deferral_resolved" | "deferral_abandoned";
+export type DeferralCondition = {
+    id: string;
+    statement: string;
+    state: "open" | "addressed";
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    updatedBy: string;
+};
+export type DeferralEvent = {
+    id: string;
+    eventType: DeferralEventType;
+    createdAt: string;
+    createdBy: string;
+} & Record<string, unknown>;
+export type DecisionEntryType = "argument" | "decision" | "note";
+export type DecisionEntry = {
+    id: string;
+    entryType: DecisionEntryType;
+    body: string;
+    createdAt: string;
+    createdBy: string;
+    decidedBy?: string;
+    rationale?: string;
+};
+export type TaskEntryType = "comment" | "status_change" | "note";
+export type TaskStatus = "open" | "in_progress" | "blocked" | "done";
+export type TaskEntry = {
+    id: string;
+    entryType: TaskEntryType;
+    body: string;
+    createdAt: string;
+    createdBy: string;
+    status?: TaskStatus;
+};
+export type JournalEntryKind = "note" | "summary";
+export type AppendJournalNoteInput = {
+    workspaceId: string;
+    body: string;
+    tag?: string;
+};
+export type ReadJournalInput = {
+    workspaceId: string;
+    limit?: number;
+    includeArchived?: boolean;
+};
+export type ReadJournalResult = {
+    workspaceId: string;
+    readTier: "hot" | "cold";
+    compaction: {
+        activeRawNoteCount: number;
+        threshold: number;
+        recommended: boolean;
+    };
+    entries: DxcRecord[];
+};
+export type GetJournalEntryInput = {
+    workspaceId: string;
+    id: string;
+};
+export type AppendJournalSummaryInput = {
+    workspaceId: string;
+    body: string;
+    covers: string[];
+    tag?: string;
+};
+export type CreateRecordInput = {
+    id?: string;
+    workspaceId?: string;
+    title?: string;
+    summary?: string;
+    fields?: Record<string, unknown>;
+    allowManagedFields?: boolean;
+};
+export type UpdateRecordInput = {
+    recordType: CollectionName;
+    id: string;
+    workspaceId?: string;
+    title?: string;
+    summary?: string;
+    fields?: Record<string, unknown>;
+    unsetFields?: string[];
+    allowManagedFields?: boolean;
+    revisionNote?: string;
+};
+export type AppendReviewNoteInput = {
+    recordType: ReviewableRecordType;
+    id: string;
+    workspaceId: string;
+    body: string;
+    important?: boolean;
+};
+export type AppendChangeEventInput = {
+    workspaceId: string;
+    changeId: string;
+    eventType: ChangeEventType;
+    event: Record<string, unknown>;
+};
+export type AppendDeferralEventInput = {
+    workspaceId: string;
+    deferralId: string;
+    eventType: DeferralEventType;
+    event: Record<string, unknown>;
+};
+export type AppendDecisionEntryInput = {
+    workspaceId: string;
+    decisionId: string;
+    entryType: DecisionEntryType;
+    body: string;
+    decidedBy?: string;
+    rationale?: string;
+};
+export type AppendTaskEntryInput = {
+    workspaceId: string;
+    taskId: string;
+    entryType: TaskEntryType;
+    body: string;
+    status?: TaskStatus;
+};
+export type UnlinkRecordsInput = {
+    fromType: CollectionName;
+    fromId: string;
+    toType: CollectionName;
+    toId: string;
+    workspaceId?: string;
+    relationship?: string;
+};
+export type ArchiveRecordInput = {
+    recordType: CollectionName;
+    id: string;
+    workspaceId?: string;
+    reason?: string;
+    supersededByType?: CollectionName;
+    supersededById?: string;
+};
+export type LinkedRecordsResult = {
+    source: DxcRecord;
+    outbound: Array<{
+        edge: RecordEdge;
+        record: DxcRecord;
+    }>;
+    inbound: Array<{
+        edge: RecordEdge;
+        record: DxcRecord;
+    }>;
+};
+export type DxcompleteTicketEntryDirection = "submitter_entry" | "dxcomplete_reply";
+export type DxcompleteTicketEntry = {
+    id: string;
+    body: string;
+    createdAt: string;
+    createdBy: string;
+    direction: DxcompleteTicketEntryDirection;
+    addressedToActorId?: string;
+    readAt?: string;
+};
+export type CreateDxcompleteTicketInput = {
+    title: string;
+    body: string;
+};
+export type AppendDxcompleteTicketInput = {
+    id: string;
+    body: string;
+};
+export type AppendDxcompleteTicketReplyInput = {
+    id: string;
+    body: string;
+    addressedToActorId: string;
+};
+export type ArchiveDxcompleteTicketInput = {
+    id: string;
+};
+export type ReadDxcompleteTicketInput = {
+    id: string;
+};
+export type DxcompleteTicketUnreadReplySummary = {
+    id: string;
+    createdAt: string;
+    createdBy: string;
+    direction: "dxcomplete_reply";
+    addressedToActorId?: string;
+};
+export type DxcompleteTicketUnreadReplyResult = {
+    ticketId: string;
+    title?: string;
+    updatedAt: string;
+    unreadReplyCount: number;
+    newestReplyAt?: string;
+    replies: DxcompleteTicketUnreadReplySummary[];
+};
+export declare const RUNTIME_ACTOR_ID = "dxcomplete-runtime";
+export declare function assertCollectionName(value: string): CollectionName;
+export declare function createRecord(db: Db, recordType: CollectionName, input: CreateRecordInput, actorId: string): Promise<DxcRecord>;
+export declare function listRecords(db: Db, recordType: CollectionName, limit: number, options?: {
+    includeArchived?: boolean;
+    workspaceId?: string;
+}): Promise<DxcRecord[]>;
+export declare function getRecord(db: Db, recordType: RuntimeCollectionName, id: string, options?: {
+    workspaceId?: string;
+    allowAnyWorkspace?: boolean;
+}): Promise<DxcRecord | null>;
+export declare function listLinkedRecords(db: Db, input: {
+    recordType: CollectionName;
+    id: string;
+    workspaceId?: string;
+    direction?: "outbound" | "inbound" | "both";
+    relationship?: string;
+    includeArchived?: boolean;
+}): Promise<LinkedRecordsResult>;
+export declare function migrateLegacyIntakeItemsToDxcompleteTickets(db: Db): Promise<{
+    copied: number;
+    skipped: number;
+}>;
+export declare function createDxcompleteTicket(db: Db, input: CreateDxcompleteTicketInput, actor: ActorContext): Promise<DxcRecord>;
+export declare function getDxcompleteTicket(db: Db, id: string, actor: ActorContext): Promise<DxcRecord>;
+export declare function listDxcompleteTickets(db: Db, actor: ActorContext, limit: number, options?: {
+    includeArchived?: boolean;
+}): Promise<DxcRecord[]>;
+export declare function appendDxcompleteTicket(db: Db, input: AppendDxcompleteTicketInput, actor: ActorContext): Promise<DxcRecord>;
+export declare function appendDxcompleteTicketReply(db: Db, input: AppendDxcompleteTicketReplyInput, actorId?: string): Promise<DxcRecord>;
+export declare function appendJournalNote(db: Db, input: AppendJournalNoteInput, actorId: string): Promise<DxcRecord>;
+export declare function readJournal(db: Db, input: ReadJournalInput): Promise<ReadJournalResult>;
+export declare function getJournalEntry(db: Db, input: GetJournalEntryInput): Promise<DxcRecord>;
+export declare function appendJournalSummary(db: Db, input: AppendJournalSummaryInput, actorId: string): Promise<DxcRecord>;
+export declare function appendReviewNote(db: Db, input: AppendReviewNoteInput, actorId: string): Promise<DxcRecord>;
+export declare function appendChangeEvent(db: Db, input: AppendChangeEventInput, actorId: string): Promise<DxcRecord>;
+export declare function appendDeferralEvent(db: Db, input: AppendDeferralEventInput, actorId: string): Promise<DxcRecord>;
+export declare function appendDecisionEntry(db: Db, input: AppendDecisionEntryInput, actorId: string): Promise<DxcRecord>;
+export declare function appendTaskEntry(db: Db, input: AppendTaskEntryInput, actorId: string): Promise<DxcRecord>;
+export declare function decisionEntryToCurrentDecision(entry: DecisionEntry): Record<string, unknown>;
+export declare function taskEntryToCurrentStatus(entry: TaskEntry): Record<string, unknown>;
+export declare function listUnreadDxcompleteTicketReplies(db: Db, actor: ActorContext, limit: number): Promise<DxcompleteTicketUnreadReplyResult[]>;
+export declare function readDxcompleteTicket(db: Db, input: ReadDxcompleteTicketInput, actor: ActorContext): Promise<DxcRecord>;
+export declare function archiveDxcompleteTicket(db: Db, input: ArchiveDxcompleteTicketInput, actor: ActorContext): Promise<DxcRecord>;
+export declare function updateRecord(db: Db, input: UpdateRecordInput, actorId: string): Promise<DxcRecord>;
+export declare function archiveRecord(db: Db, input: ArchiveRecordInput, actorId: string): Promise<DxcRecord>;
+export declare function linkRecords(db: Db, input: {
+    fromType: CollectionName;
+    fromId: string;
+    toType: CollectionName;
+    toId: string;
+    workspaceId?: string;
+    relationship?: string;
+}, actorId: string): Promise<DxcRecord>;
+export declare function unlinkRecords(db: Db, input: UnlinkRecordsInput, actorId: string): Promise<DxcRecord>;