soja-cli 1.4.0

package/dist/application/services/project-service.js

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { ConflictError, NotFoundError } from '../../domain/errors.js';
+import { deriveProjectKey, makeUnique } from '../../domain/naming.js';
+import { activeCount, emptyStatusCounts } from '../../domain/task.js';
+import { GitError } from '../../git/types.js';
+import { resolveRepositoryRoot } from '../repository-root.js';
+import { optionalText, parseInput } from '../validation.js';
+const projectKeySchema = z
+    .string()
+    .trim()
+    .toUpperCase()
+    .regex(/^[A-Z][A-Z0-9]{1,9}$/, { error: 'Keys are 2–10 letters or digits and start with a letter (e.g. ENROLL).' });
+const createProjectSchema = z.object({
+    name: z.string().trim().min(1, { error: 'Name the project.' }).max(60),
+    key: projectKeySchema.optional(),
+    description: optionalText(500),
+    repositoryUrl: optionalText(500),
+    repositoryPath: optionalText(500),
+});
+const updateProjectSchema = z.object({
+    name: z.string().trim().min(1, { error: 'Name the project.' }).max(60).optional(),
+    description: optionalText(500),
+    repositoryUrl: optionalText(500),
+});
+export class ProjectService {
+    repos;
+    git;
+    constructor(repos, git) {
+        this.repos = repos;
+        this.git = git;
+    }
+    async list(session) {
+        const [projects, rows] = await Promise.all([
+            this.repos.projects.listByWorkspace(session.workspace.id),
+            this.repos.tasks.countByProjectAndStatus(session.workspace.id),
+        ]);
+        return projects.map((project) => {
+            const counts = emptyStatusCounts();
+            for (const row of rows)
+                if (row.projectId === project.id)
+                    counts[row.status] += row.count;
+            return { ...project, counts, active: activeCount(counts) };
+        });
+    }
+    async create(session, input) {
+        const { name, key, ...rest } = parseInput(createProjectSchema, input);
+        return this.repos.transaction(async () => {
+            const existing = await this.repos.projects.listByWorkspace(session.workspace.id);
+            if (existing.some((project) => project.name.toLowerCase() === name.toLowerCase())) {
+                throw new ConflictError(`${name} already exists in ${session.workspace.name}.`);
+            }
+            const keys = new Set(existing.map((project) => project.key));
+            if (key && keys.has(key))
+                throw new ConflictError(`The key ${key} is already used by another project.`);
+            return this.repos.projects.create({
+                workspaceId: session.workspace.id,
+                name,
+                key: key ?? makeUnique(deriveProjectKey(name), (candidate) => keys.has(candidate)),
+                description: rest.description ?? null,
+                repositoryUrl: rest.repositoryUrl ?? null,
+                repositoryPath: rest.repositoryPath ?? null,
+            });
+        });
+    }
+    async update(session, project, changes) {
+        const data = parseInput(updateProjectSchema, changes);
+        await this.get(session, project.id);
+        if (data.name !== undefined) {
+            const name = data.name;
+            const others = (await this.repos.projects.listByWorkspace(session.workspace.id)).filter((other) => other.id !== project.id);
+            if (others.some((other) => other.name.toLowerCase() === name.toLowerCase())) {
+                throw new ConflictError(`${name} already exists in ${session.workspace.name}.`);
+            }
+        }
+        const patch = Object.fromEntries(Object.entries(data).filter(([, value]) => value !== undefined));
+        return Object.keys(patch).length ? this.repos.projects.update(project.id, patch) : project;
+    }
+    async get(session, id) {
+        const project = await this.repos.projects.findById(id);
+        if (!project || project.workspaceId !== session.workspace.id) {
+            throw new NotFoundError('That project does not exist in this workspace.');
+        }
+        return project;
+    }
+    /**
+     * Links a project to the local Git repository containing `path` (the
+     * top-level directory is stored). Fills the repository URL from `origin`
+     * when the project does not have one yet.
+     */
+    async linkRepository(session, project, path) {
+        const root = await resolveRepositoryRoot(this.git, path);
+        await this.get(session, project.id);
+        const repositoryUrl = project.repositoryUrl ?? (await this.git.originUrl(root));
+        return this.repos.projects.update(project.id, { repositoryPath: root, repositoryUrl });
+    }
+    async unlinkRepository(session, project) {
+        await this.get(session, project.id);
+        return this.repos.projects.update(project.id, { repositoryPath: null });
+    }
+    /** The project linked to the repository containing `path`, if any. Never throws for non-repositories. */
+    async findByRepository(session, path) {
+        let root;
+        try {
+            root = await this.git.repositoryRoot(path);
+        }
+        catch (error) {
+            if (error instanceof GitError)
+                return null;
+            throw error;
+        }
+        if (!root)
+            return null;
+        const projects = await this.repos.projects.listByWorkspace(session.workspace.id);
+        return projects.find((project) => project.repositoryPath === root) ?? null;
+    }
+    /** Finds a project by key (`ENROLL`) or name (`EnrollBridge`), case-insensitively. */
+    async resolve(session, keyOrName) {
+        const needle = keyOrName.trim().toLowerCase();
+        const projects = await this.repos.projects.listByWorkspace(session.workspace.id);
+        const project = projects.find((candidate) => candidate.key.toLowerCase() === needle) ??
+            projects.find((candidate) => candidate.name.toLowerCase() === needle);
+        if (!project) {
+            throw new NotFoundError(`No project called “${keyOrName}” in ${session.workspace.name}.`, {
+                hint: 'List them with `soja project list`.',
+            });
+        }
+        return project;
+    }
+}

package/dist/application/services/session-service.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { displayNameSchema, parseInput, usernameSchema } from '../validation.js';
+const setupSchema = z.object({
+    displayName: displayNameSchema,
+    username: usernameSchema,
+    workspaceName: z.string().trim().min(1, { error: 'Name the workspace.' }).max(60),
+});
+export class SessionService {
+    repos;
+    config;
+    workspaces;
+    constructor(repos, config, workspaces) {
+        this.repos = repos;
+        this.config = config;
+        this.workspaces = workspaces;
+    }
+    /** The configured user, even without a usable workspace; null before setup. */
+    async user() {
+        const config = this.config.load();
+        return config?.userId ? this.repos.users.findById(config.userId) : null;
+    }
+    /** The configured user and workspace, or null when setup is needed. */
+    async current() {
+        const config = this.config.load();
+        if (!config?.userId || !config.workspaceId)
+            return null;
+        const [user, workspace] = await Promise.all([
+            this.repos.users.findById(config.userId),
+            this.repos.workspaces.findById(config.workspaceId),
+        ]);
+        if (!user)
+            return null;
+        if (workspace && (await this.repos.workspaces.findMember(workspace.id, user.id))) {
+            return { user, workspace };
+        }
+        // The active workspace vanished (db reset, left it): fall back to any other.
+        const [fallback] = await this.repos.workspaces.listForUser(user.id);
+        return fallback ? this.workspaces.switchTo(user, fallback.id) : null;
+    }
+    /**
+     * First run: creates the local user and first workspace, then persists
+     * them as the active session. Re-running setup against an existing
+     * database reuses a matching username instead of failing.
+     */
+    async setup(input) {
+        const { displayName, username, workspaceName } = parseInput(setupSchema, input);
+        const user = (await this.repos.users.findByUsername(username)) ?? (await this.repos.users.create({ username, displayName }));
+        const existing = (await this.repos.workspaces.listForUser(user.id)).find((workspace) => workspace.name.toLowerCase() === workspaceName.toLowerCase());
+        const workspace = existing ?? (await this.workspaces.create(user, { name: workspaceName }));
+        return this.workspaces.switchTo(user, workspace.id);
+    }
+}

package/dist/application/services/task-service.js

@@ -0,0 +1,350 @@
+import { z } from 'zod';
+import { NotFoundError, ValidationError } from '../../domain/errors.js';
+import { compareByUrgency, formatTaskRef, isClosed, parseTaskRef, suggestBranchName, TASK_PRIORITIES, TASK_STATUSES, TASK_TYPES, } from '../../domain/task.js';
+import { planStatusChange } from '../../domain/workflow.js';
+import { filterToQuery } from '../filters.js';
+import { buildTimeline } from '../timeline.js';
+import { optionalText, parseInput } from '../validation.js';
+const titleSchema = z
+    .string()
+    .trim()
+    .min(1, { error: 'A task needs a title.' })
+    .max(200, { error: 'Keep the title under 200 characters.' });
+const createTaskSchema = z.object({
+    title: titleSchema,
+    description: optionalText(10_000),
+    projectId: z.string().nullable().optional(),
+    type: z.enum(TASK_TYPES).default('feature'),
+    priority: z.enum(TASK_PRIORITIES).default('medium'),
+    status: z.enum(TASK_STATUSES).default('todo'),
+    /** Omitted means "me"; null means unassigned. */
+    assigneeId: z.string().nullable().optional(),
+    requester: optionalText(80),
+});
+const changesSchema = z.object({
+    title: titleSchema.optional(),
+    description: optionalText(10_000),
+    projectId: z.string().nullable().optional(),
+    type: z.enum(TASK_TYPES).optional(),
+    priority: z.enum(TASK_PRIORITIES).optional(),
+    status: z.enum(TASK_STATUSES).optional(),
+    assigneeId: z.string().nullable().optional(),
+    requester: optionalText(80),
+    branch: optionalText(250),
+    /** Bookkeeping for merges; changes are not shown in the timeline. */
+    baseBranch: optionalText(250),
+    branchStart: optionalText(64),
+    /** Archive (hide from lists) or restore. */
+    archived: z.boolean().optional(),
+});
+const commentSchema = z
+    .string()
+    .trim()
+    .min(1, { error: 'The comment is empty.' })
+    .max(10_000, { error: 'Keep comments under 10,000 characters.' });
+export class TaskService {
+    repos;
+    clock;
+    constructor(repos, clock = () => new Date()) {
+        this.repos = repos;
+        this.clock = clock;
+    }
+    async list(session, filter, options = {}) {
+        const query = { ...filterToQuery(session, filter), ...options };
+        const tasks = await this.repos.tasks.list(query);
+        return this.present(session, tasks.sort(compareByUrgency));
+    }
+    /** Title substring or task number (`SOJA-12`, `12`), across open and closed tasks. */
+    async search(session, text, limit = 50) {
+        const trimmed = text.trim();
+        if (!trimmed)
+            return [];
+        const exact = parseTaskRef(trimmed);
+        const tasks = await this.repos.tasks.list({
+            workspaceId: session.workspace.id,
+            search: { text: trimmed, number: exact },
+            // Search is how archived tasks are found again.
+            archived: 'include',
+            limit,
+        });
+        // An exact ID hit goes first; the rest keep newest-first order.
+        tasks.sort((a, b) => Number(b.number === exact) - Number(a.number === exact));
+        return this.present(session, tasks);
+    }
+    async get(session, target) {
+        const task = await this.resolve(session, target);
+        const [view, activity, comments, projects] = await Promise.all([
+            this.presentOne(session, task),
+            this.repos.activity.listByTask(task.id),
+            this.repos.comments.listByTask(task.id),
+            this.repos.projects.listByWorkspace(session.workspace.id),
+        ]);
+        const userIds = new Set([task.creatorId]);
+        for (const item of activity) {
+            if (item.userId)
+                userIds.add(item.userId);
+            if (item.type === 'assigned') {
+                userIds.add(item.metadata.to);
+                if (item.metadata.from)
+                    userIds.add(item.metadata.from);
+            }
+            if (item.type === 'unassigned')
+                userIds.add(item.metadata.from);
+        }
+        for (const comment of comments)
+            userIds.add(comment.userId);
+        const users = new Map((await this.repos.users.findByIds([...userIds])).map((user) => [user.id, toUserRef(user)]));
+        return {
+            ...view,
+            creator: users.get(task.creatorId) ?? null,
+            timeline: buildTimeline(activity, comments, {
+                users,
+                projects: new Map(projects.map((project) => [project.id, toProjectRef(project)])),
+            }),
+            suggestedBranch: suggestBranchName(task),
+        };
+    }
+    async create(session, input, options = {}) {
+        const data = parseInput(createTaskSchema, input);
+        const assigneeId = data.assigneeId === undefined ? session.user.id : data.assigneeId;
+        const projectId = data.projectId ?? null;
+        await this.assertProject(session, projectId);
+        await this.assertMember(session, assigneeId);
+        const now = this.clock();
+        const task = await this.repos.transaction(async () => {
+            const created = await this.repos.tasks.create({
+                ...(options.id ? { id: options.id } : {}),
+                ...(options.number !== undefined ? { number: options.number } : {}),
+                workspaceId: session.workspace.id,
+                projectId,
+                title: data.title,
+                description: data.description ?? null,
+                type: data.type,
+                priority: data.priority,
+                status: data.status,
+                assigneeId,
+                creatorId: session.user.id,
+                requester: data.requester ?? null,
+                branch: null,
+                baseBranch: null,
+                branchStart: null,
+                startedAt: data.status === 'in_progress' ? now : null,
+                completedAt: data.status === 'done' ? now : null,
+            });
+            await this.repos.activity.record(created.id, session.user.id, { type: 'task_created', metadata: {} });
+            return created;
+        });
+        return this.presentOne(session, task);
+    }
+    /**
+     * Applies any combination of edits. Each real change is written as its own
+     * activity entry, so the timeline reads like a log of decisions.
+     */
+    async update(session, target, changes) {
+        const data = parseInput(changesSchema, changes);
+        const task = await this.resolve(session, target);
+        if (data.projectId !== undefined)
+            await this.assertProject(session, data.projectId);
+        if (data.assigneeId !== undefined)
+            await this.assertMember(session, data.assigneeId);
+        const patch = {};
+        const events = [];
+        const changed = (next, current) => next !== undefined && next !== current;
+        if (changed(data.title, task.title)) {
+            patch.title = data.title;
+            events.push({ type: 'task_updated', metadata: { field: 'title', from: task.title, to: data.title } });
+        }
+        if (changed(data.description, task.description)) {
+            patch.description = data.description;
+            // Descriptions can be long; the timeline only records that it changed.
+            const to = data.description ? 'edited' : null;
+            events.push({ type: 'task_updated', metadata: { field: 'description', from: null, to } });
+        }
+        if (changed(data.requester, task.requester)) {
+            patch.requester = data.requester;
+            events.push({ type: 'task_updated', metadata: { field: 'requester', from: task.requester, to: data.requester } });
+        }
+        if (changed(data.branch, task.branch)) {
+            patch.branch = data.branch;
+            events.push({ type: 'task_updated', metadata: { field: 'branch', from: task.branch, to: data.branch } });
+        }
+        if (changed(data.baseBranch, task.baseBranch))
+            patch.baseBranch = data.baseBranch;
+        if (changed(data.branchStart, task.branchStart))
+            patch.branchStart = data.branchStart;
+        if (changed(data.type, task.type)) {
+            patch.type = data.type;
+            events.push({ type: 'task_updated', metadata: { field: 'type', from: task.type, to: data.type } });
+        }
+        if (changed(data.priority, task.priority)) {
+            patch.priority = data.priority;
+            events.push({ type: 'priority_changed', metadata: { from: task.priority, to: data.priority } });
+        }
+        if (changed(data.projectId, task.projectId)) {
+            patch.projectId = data.projectId;
+            events.push({ type: 'project_changed', metadata: { from: task.projectId, to: data.projectId } });
+        }
+        if (changed(data.assigneeId, task.assigneeId)) {
+            patch.assigneeId = data.assigneeId;
+            if (data.assigneeId)
+                events.push({ type: 'assigned', metadata: { from: task.assigneeId, to: data.assigneeId } });
+            else if (task.assigneeId)
+                events.push({ type: 'unassigned', metadata: { from: task.assigneeId } });
+        }
+        if (data.archived !== undefined && data.archived !== (task.archivedAt !== null)) {
+            patch.archivedAt = data.archived ? this.clock() : null;
+            events.push({ type: data.archived ? 'task_archived' : 'task_unarchived', metadata: {} });
+        }
+        if (data.status) {
+            const change = planStatusChange(task, data.status, this.clock());
+            if (change) {
+                Object.assign(patch, change.patch);
+                events.push(change.event);
+            }
+        }
+        if (events.length === 0) {
+            if (Object.keys(patch).length === 0)
+                return this.presentOne(session, task);
+            return this.presentOne(session, await this.repos.tasks.update(task.id, patch));
+        }
+        const updated = await this.repos.transaction(async () => {
+            const result = await this.repos.tasks.update(task.id, patch);
+            for (const event of events)
+                await this.repos.activity.record(task.id, session.user.id, event);
+            return result;
+        });
+        return this.presentOne(session, updated);
+    }
+    /**
+     * Take the task: assign it to me and move it to In Progress. The Git flow
+     * (`soja start`) reuses this and also records the branch, in one transaction.
+     */
+    start(session, target, extra = {}) {
+        return this.update(session, target, { assigneeId: session.user.id, status: 'in_progress', ...extra });
+    }
+    archive(session, target) {
+        return this.update(session, target, { archived: true });
+    }
+    restore(session, target) {
+        return this.update(session, target, { archived: false });
+    }
+    /**
+     * Deletes the task with its comments and timeline, for good. Owners only;
+     * archiving is the reversible alternative.
+     */
+    async remove(session, target) {
+        const task = await this.resolve(session, target);
+        const member = await this.repos.workspaces.findMember(session.workspace.id, session.user.id);
+        if (member?.role !== 'owner') {
+            throw new ValidationError('Only workspace owners can delete tasks.', { hint: 'Archive it instead: it leaves the lists and can be restored.' });
+        }
+        await this.repos.transaction(() => this.repos.tasks.delete(task.id));
+        return { id: task.id, number: task.number };
+    }
+    complete(session, target) {
+        return this.update(session, target, { status: 'done' });
+    }
+    async reopen(session, target) {
+        const task = await this.resolve(session, target);
+        if (!isClosed(task.status)) {
+            throw new ValidationError(`${formatTaskRef(task.number)} is already open.`);
+        }
+        return this.update(session, task, { status: 'todo' });
+    }
+    async comment(session, target, body, options = {}) {
+        const text = parseInput(commentSchema, body);
+        const task = await this.resolve(session, target);
+        await this.repos.transaction(async () => {
+            const comment = await this.repos.comments.create({ ...(options.id ? { id: options.id } : {}), taskId: task.id, userId: session.user.id, body: text });
+            await this.repos.activity.record(task.id, session.user.id, {
+                type: 'comment_added',
+                metadata: { commentId: comment.id },
+            });
+            // Commenting counts as touching the task.
+            await this.repos.tasks.update(task.id, {});
+        });
+    }
+    /**
+     * Records a Git fact that happened on this machine (commit, merge, push…),
+     * optionally updating the task's branch bookkeeping, in one transaction.
+     */
+    async recordGitEvent(session, target, event, fields = {}) {
+        const task = await this.resolve(session, target);
+        const updated = await this.repos.transaction(async () => {
+            const result = await this.repos.tasks.update(task.id, fields);
+            await this.repos.activity.record(task.id, session.user.id, event);
+            return result;
+        });
+        return this.presentOne(session, updated);
+    }
+    /** Requesters used before in this workspace, most frequent first. Feeds autocomplete. */
+    async knownRequesters(session) {
+        const tasks = await this.repos.tasks.list({ workspaceId: session.workspace.id });
+        const counts = new Map();
+        for (const task of tasks)
+            if (task.requester)
+                counts.set(task.requester, (counts.get(task.requester) ?? 0) + 1);
+        return [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([name]) => name);
+    }
+    async resolve(session, target) {
+        if (typeof target === 'object') {
+            const task = await this.repos.tasks.findById(target.id);
+            if (task && task.workspaceId === session.workspace.id)
+                return task;
+            throw new NotFoundError('That task no longer exists.');
+        }
+        const number = typeof target === 'number' ? target : parseTaskRef(target);
+        if (number === null) {
+            throw new ValidationError(`“${String(target)}” is not a task ID.`, { hint: 'Use something like SOJA-12.' });
+        }
+        const task = await this.repos.tasks.findByNumber(session.workspace.id, number);
+        if (!task)
+            throw new NotFoundError(`${formatTaskRef(number)} does not exist in ${session.workspace.name}.`);
+        return task;
+    }
+    async assertProject(session, projectId) {
+        if (projectId === null)
+            return;
+        const project = await this.repos.projects.findById(projectId);
+        if (!project || project.workspaceId !== session.workspace.id) {
+            throw new NotFoundError('That project does not exist in this workspace.');
+        }
+    }
+    async assertMember(session, userId) {
+        if (userId === null)
+            return;
+        if (!(await this.repos.workspaces.findMember(session.workspace.id, userId))) {
+            throw new ValidationError(`Only members of ${session.workspace.name} can be assigned.`);
+        }
+    }
+    async presentOne(session, task) {
+        return (await this.presenter(session, [task]))(task);
+    }
+    async present(session, tasks) {
+        if (tasks.length === 0)
+            return [];
+        return tasks.map(await this.presenter(session, tasks));
+    }
+    /** Loads the projects and assignees `tasks` reference, and returns a mapper to views. */
+    async presenter(session, tasks) {
+        const assigneeIds = [...new Set(tasks.flatMap((task) => (task.assigneeId ? [task.assigneeId] : [])))];
+        const [projects, users] = await Promise.all([
+            this.repos.projects.listByWorkspace(session.workspace.id),
+            this.repos.users.findByIds(assigneeIds),
+        ]);
+        const projectById = new Map(projects.map((project) => [project.id, toProjectRef(project)]));
+        const userById = new Map(users.map((user) => [user.id, toUserRef(user)]));
+        return (task) => ({
+            ...task,
+            ref: formatTaskRef(task.number),
+            project: task.projectId ? (projectById.get(task.projectId) ?? null) : null,
+            assignee: task.assigneeId ? (userById.get(task.assigneeId) ?? null) : null,
+        });
+    }
+}
+function toUserRef(user) {
+    return { id: user.id, username: user.username, displayName: user.displayName };
+}
+function toProjectRef(project) {
+    return { id: project.id, name: project.name, key: project.key };
+}

package/dist/application/services/update-service.js

@@ -0,0 +1,60 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+const CHECK_EVERY_MS = 24 * 60 * 60 * 1000;
+/** Newer versions of SOJA from npm. Checks at most once a day unless asked. */
+export class UpdateService {
+    releases;
+    current;
+    cacheFile;
+    clock;
+    constructor(releases, current, cacheFile, clock = () => new Date()) {
+        this.releases = releases;
+        this.current = current;
+        this.cacheFile = cacheFile;
+        this.clock = clock;
+    }
+    /** Fresh from GitHub. */
+    async check() {
+        const latest = (await this.releases.latest()).replace(/^v/, '');
+        this.remember(latest);
+        return { current: this.current, latest, available: isNewer(latest, this.current) };
+    }
+    /** For a quiet notice: uses yesterday's answer when it is recent, and never throws. */
+    async cachedCheck() {
+        try {
+            const cached = JSON.parse(readFileSync(this.cacheFile, 'utf8'));
+            if (this.clock().getTime() - new Date(cached.checkedAt).getTime() < CHECK_EVERY_MS) {
+                return { current: this.current, latest: cached.latest, available: isNewer(cached.latest, this.current) };
+            }
+        }
+        catch {
+            // No cache yet, or unreadable: ask npm.
+        }
+        return this.check().catch(() => null);
+    }
+    /** Downloads and installs `latest` (the terminal is attached for npm). */
+    async install(latest) {
+        const file = await this.releases.download(latest);
+        await this.releases.install(file);
+    }
+    remember(latest) {
+        try {
+            mkdirSync(dirname(this.cacheFile), { recursive: true });
+            writeFileSync(this.cacheFile, JSON.stringify({ checkedAt: this.clock().toISOString(), latest }));
+        }
+        catch {
+            // The cache only saves a request.
+        }
+    }
+}
+/** `1.10.0` > `1.9.2`. Pre-release suffixes are ignored. */
+export function isNewer(candidate, current) {
+    const parts = (version) => version.split('-')[0]?.split('.').map((part) => Number(part) || 0) ?? [];
+    const [a, b] = [parts(candidate), parts(current)];
+    for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+        const difference = (a[index] ?? 0) - (b[index] ?? 0);
+        if (difference !== 0)
+            return difference > 0;
+    }
+    return false;
+}

package/dist/application/services/workspace-service.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { ConflictError, NotFoundError } from '../../domain/errors.js';
+import { makeUnique, slugify } from '../../domain/naming.js';
+import { displayNameSchema, optionalText, parseInput, usernameSchema } from '../validation.js';
+const createWorkspaceSchema = z.object({
+    name: z.string().trim().min(1, { error: 'Name the workspace.' }).max(60),
+    description: optionalText(500),
+});
+const addMemberSchema = z.object({
+    username: usernameSchema,
+    displayName: displayNameSchema.optional(),
+});
+export class WorkspaceService {
+    repos;
+    config;
+    constructor(repos, config) {
+        this.repos = repos;
+        this.config = config;
+    }
+    list(user) {
+        return this.repos.workspaces.listForUser(user.id);
+    }
+    async create(owner, input) {
+        const { name, description } = parseInput(createWorkspaceSchema, input);
+        return this.repos.transaction(async () => {
+            const slug = await uniqueSlug(slugify(name) || 'workspace', (candidate) => this.repos.workspaces.findBySlug(candidate));
+            const workspace = await this.repos.workspaces.create({ name, slug, description: description ?? null });
+            await this.repos.workspaces.addMember({ workspaceId: workspace.id, userId: owner.id, role: 'owner' });
+            return workspace;
+        });
+    }
+    /** Makes a workspace active and remembers it in the config file. Accepts an id or a slug. */
+    async switchTo(user, idOrSlug) {
+        const workspace = (await this.repos.workspaces.findById(idOrSlug)) ?? (await this.repos.workspaces.findBySlug(slugify(idOrSlug)));
+        if (!workspace || !(await this.repos.workspaces.findMember(workspace.id, user.id))) {
+            throw new NotFoundError(`You are not a member of a workspace called “${idOrSlug}”.`, {
+                hint: 'List yours with `soja workspace list`.',
+            });
+        }
+        // Keep machine settings (parent folders, remote server) when switching.
+        const current = this.config.load();
+        this.config.save({ parentFolders: [], ...current, mode: 'local', userId: user.id, workspaceId: workspace.id });
+        return { user, workspace };
+    }
+    async members(session) {
+        const members = await this.repos.workspaces.listMembers(session.workspace.id);
+        return members.map(({ id, username, displayName, role }) => ({ id, username, displayName, role }));
+    }
+    async findMember(session, username) {
+        const normalized = username.trim().replace(/^@/, '').toLowerCase();
+        const member = (await this.members(session)).find((candidate) => candidate.username === normalized);
+        if (!member) {
+            throw new NotFoundError(`@${normalized} is not a member of ${session.workspace.name}.`);
+        }
+        return member;
+    }
+    /**
+     * Adds a developer to the workspace. In local mode developers are plain
+     * records (no login), so an unknown username creates one.
+     */
+    async addMember(session, input) {
+        const { username, displayName } = parseInput(addMemberSchema, input);
+        return this.repos.transaction(async () => {
+            const user = (await this.repos.users.findByUsername(username)) ??
+                (await this.repos.users.create({ username, displayName: displayName ?? username }));
+            if (await this.repos.workspaces.findMember(session.workspace.id, user.id)) {
+                throw new ConflictError(`@${username} is already in ${session.workspace.name}.`);
+            }
+            await this.repos.workspaces.addMember({ workspaceId: session.workspace.id, userId: user.id, role: 'member' });
+            return { id: user.id, username: user.username, displayName: user.displayName, role: 'member' };
+        });
+    }
+}
+async function uniqueSlug(base, find) {
+    const taken = new Set();
+    for (let candidate = base;; candidate = makeUnique(base, (value) => taken.has(value), '-')) {
+        if (!(await find(candidate)))
+            return candidate;
+        taken.add(candidate);
+    }
+}