@skillcdn/console 0.1.18 → 0.1.19

package/src/console.tsx

@@ -43,11 +43,13 @@ import { ConnectWords } from "./components/connect.js";
 import { DecisionForm } from "./components/decision-form.js";
 import { DecisionCard, DecisionList, type DecisionListProps } from "./components/decision-list.js";
 import { EventFeed, type EventFeedProps } from "./components/event-feed.js";
-import { GoalForm, GoalList, type GoalListProps, GoalView } from "./components/goals.js";
+import { GoalForm, GoalList, type GoalListProps, GoalView, goalMonth } from "./components/goals.js";
+import { PAGE_SIZE } from "./components/paged.js";
 import { ListingForm, PeopleList, type PeopleListProps } from "./components/people.js";
 import {
   MemberList,
   type MemberListProps,
+  PackTokenForm,
   ProjectForm,
   ProjectList,
   type ProjectListProps,
@@ -75,6 +77,8 @@ import {
   EmptyState,
   personName,
   Spinner,
+  StateBadge,
+  Time,
 } from "./components/ui.js";
 import { WorkList, type WorkListProps } from "./components/work.js";
 import { ConnectPage } from "./connect-page.js";
@@ -95,6 +99,7 @@ import {
   customPageHref,
   decisionHref,
   docHref,
+  type GoalTaskView,
   goalHref,
   matchRoute,
   type Navigation,
@@ -442,6 +447,102 @@ function ProjectsPage(props: {
   );
 }
 
+/**
+ * The archive of the board (ADR-0029): the tasks put away, newest first, a page at a time from
+ * the server, each brought back from here by whoever may work in the project.
+ */
+function ArchivePage(props: { readonly project: RestProject; readonly data: ConsoleData }) {
+  const words = useWords();
+  const { project, data } = props;
+  const key = project.key;
+  const { busy, error, act } = useAction();
+  const [items, setItems] = useState<readonly RestTask[]>([]);
+  const [more, setMore] = useState(false);
+  const [loaded, setLoaded] = useState(false);
+  const { archivedTasks } = data.actions;
+  const feedLength = data.events.length;
+  // The first page, read again whenever the project's feed grows: something was put away or brought back.
+  // biome-ignore lint/correctness/useExhaustiveDependencies: the feed's length is what triggers the read
+  useEffect(() => {
+    const controller = new AbortController();
+    archivedTasks({ limit: PAGE_SIZE, offset: 0 }, controller.signal)
+      .then((page) => {
+        if (!controller.signal.aborted) {
+          setItems(page.items);
+          setMore(page.more);
+          setLoaded(true);
+        }
+      })
+      .catch(() => undefined);
+    return () => controller.abort();
+  }, [archivedTasks, feedLength]);
+  const onMore = () =>
+    void archivedTasks({ limit: PAGE_SIZE, offset: items.length })
+      .then((page) => {
+        setItems((current) => [...current, ...page.items]);
+        setMore(page.more);
+      })
+      .catch(() => undefined);
+  const archive = words.archive;
+  return (
+    <>
+      <div className="sc-page-head">
+        <h1 className="sc-page-title">{archive.title}</h1>
+        <LinkButton href={projectHref(key)}>{words.nav.board}</LinkButton>
+      </div>
+      <p className="sc-lead">{archive.lead}</p>
+      {error !== undefined && <Callout tone="danger">{error}</Callout>}
+      {!loaded ? (
+        <Spinner label={archive.loading} />
+      ) : items.length === 0 ? (
+        <EmptyState title={archive.empty.title} body={archive.empty.body} />
+      ) : (
+        <>
+          <ul className="sc-task-rows" aria-label={archive.title}>
+            {items.map((task) => (
+              <li key={task.id} className="sc-task-row">
+                <a className="sc-task-row-title" href={taskHref(key, task.number)}>
+                  <span className="sc-card-number">#{task.number}</span> {task.title}
+                </a>
+                <span className="sc-task-row-meta">
+                  <StateBadge state={task.state} />
+                  {task.archivedAt !== null && (
+                    <span className="sc-muted">
+                      {archive.since} <Time iso={task.archivedAt} />
+                    </span>
+                  )}
+                  <Button
+                    size="sm"
+                    variant="ghost"
+                    disabled={busy}
+                    onClick={() =>
+                      void act(async () => {
+                        await data.actions.restoreTask(task.id);
+                        setItems((current) =>
+                          current.filter((candidate) => candidate.id !== task.id),
+                        );
+                      })
+                    }
+                  >
+                    {archive.restore}
+                  </Button>
+                </span>
+              </li>
+            ))}
+          </ul>
+          {more && (
+            <div className="sc-show-more">
+              <Button variant="secondary" size="sm" onClick={onMore}>
+                {archive.more}
+              </Button>
+            </div>
+          )}
+        </>
+      )}
+    </>
+  );
+}
+
 function TaskPage(props: {
   readonly route: Extract<Route, { name: "task" }>;
   readonly project: RestProject;
@@ -455,10 +556,43 @@ function TaskPage(props: {
   const words = useWords();
   const { route, project, data, components, navigation, busy, error, act } = props;
   const key = project.key;
-  const task =
+  const current =
     route.number === undefined
       ? data.tasks.find((candidate) => candidate.id === route.id)
       : data.tasks.find((candidate) => candidate.number === route.number);
+  // A task put away is not among the board's (ADR-0029): it is asked for by itself.
+  const [fetched, setFetched] = useState<RestTask | undefined>(undefined);
+  const [missing, setMissing] = useState<string | undefined>(undefined);
+  const { fetchTask } = data.actions;
+  const wanted =
+    current === undefined && data.projectLoaded
+      ? route.number === undefined
+        ? route.id
+        : String(route.number)
+      : undefined;
+  useEffect(() => {
+    if (wanted === undefined) {
+      return;
+    }
+    const controller = new AbortController();
+    fetchTask(wanted, controller.signal)
+      .then((found) => {
+        if (!controller.signal.aborted) {
+          setFetched(found);
+        }
+      })
+      .catch(() => {
+        if (!controller.signal.aborted) {
+          setMissing(wanted);
+        }
+      });
+    return () => controller.abort();
+  }, [wanted, fetchTask]);
+  const task =
+    current ??
+    (fetched !== undefined && (fetched.id === route.id || fetched.number === route.number)
+      ? fetched
+      : undefined);
   const [history, setHistory] = useState<readonly RestEvent[] | undefined>(undefined);
   const [comments, setComments] = useState<readonly RestComment[] | undefined>(undefined);
   const { taskHistory, taskComments } = data.actions;
@@ -495,6 +629,9 @@ function TaskPage(props: {
     return () => controller.abort();
   }, [taskId, taskHistory, taskComments, feedLength]);
   if (task === undefined) {
+    if (wanted !== undefined && missing !== wanted) {
+      return <Spinner label={words.common.loading} />;
+    }
     return (
       <EmptyState
         title={words.task.noSuch.title}
@@ -545,6 +682,17 @@ function TaskPage(props: {
         void act(() => data.actions.updateDecision(decision.id, patch))
       }
       onAbandonRun={(run) => void act(() => data.actions.abandonRun(run.id))}
+      onArchive={(target) =>
+        void act(async () => {
+          await data.actions.archiveTask(target.id);
+          navigation.go(projectHref(key, "archive"));
+        })
+      }
+      onRestore={(target) =>
+        void act(async () => {
+          setFetched(await data.actions.restoreTask(target.id));
+        })
+      }
       onComment={(draft) =>
         void act(async () => {
           await data.actions.comment(task.id, {
@@ -615,6 +763,7 @@ function ProjectPage(props: {
           taskHref={href}
           onOpen={(task) => navigation.go(href(task))}
           onMove={onMove}
+          archiveHref={projectHref(key, "archive")}
           empty={
             data.tasks.length === 0 ? (
               <EmptyState
@@ -850,6 +999,10 @@ function ProjectPage(props: {
         </>
       );
     }
+    const now = today();
+    const towards = data.tasks.filter((task) => task.goalId === goal.id);
+    const month = route.month ?? goalMonth(goal, now);
+    const viewHref = (view: GoalTaskView) => goalHref(key, goal.id, { view });
     return (
       <>
         <div className="sc-page-head">
@@ -862,13 +1015,60 @@ function ProjectPage(props: {
           tasks={data.tasks}
           taskHref={href}
           docHref={toDoc}
-          editHref={owner ? goalHref(key, goal.id, "edit") : undefined}
+          today={now}
+          editHref={owner ? goalHref(key, goal.id, { form: "edit" }) : undefined}
           onMove={
             owner
-              ? (target, state) => void act(() => data.actions.updateGoal(target.id, { state }))
+              ? (target, state) =>
+                  void act(async () => {
+                    await data.actions.updateGoal(target.id, { state });
+                    // A goal closed takes its done and dropped tasks to the archive, if the person says so (ADR-0029).
+                    const closed = towards.filter(
+                      (task) => !OPEN_TASK_STATES.includes(task.state),
+                    ).length;
+                    if (
+                      (state === "done" || state === "dropped") &&
+                      closed > 0 &&
+                      window.confirm(roadmap.archiveAsk(closed))
+                    ) {
+                      await data.actions.archiveGoalTasks(target.id);
+                    }
+                  })
+              : undefined
+          }
+          onArchiveTasks={
+            owner && towards.some((task) => !OPEN_TASK_STATES.includes(task.state))
+              ? () => void act(() => data.actions.archiveGoalTasks(goal.id))
               : undefined
           }
           busy={busy}
+          view={route.view}
+          viewHref={viewHref}
+          board={
+            <components.Board
+              tasks={towards}
+              taskHref={href}
+              onOpen={(task) => navigation.go(href(task))}
+              onMove={onMove}
+              today={now}
+              archiveHref={projectHref(key, "archive")}
+              empty={
+                towards.length === 0 ? <p className="sc-muted">{roadmap.noTasks}</p> : undefined
+              }
+            />
+          }
+          calendar={
+            <components.Calendar
+              tasks={towards}
+              month={month}
+              today={now}
+              categories={data.categories}
+              goals={[goal]}
+              taskHref={href}
+              goalHref={(target) => goalHref(key, target.id)}
+              monthHref={(wanted) => goalHref(key, goal.id, { view: "calendar", month: wanted })}
+            />
+          }
         />
       </>
     );
@@ -958,6 +1158,9 @@ function ProjectPage(props: {
       </>
     );
   }
+  if (route.name === "archive") {
+    return <ArchivePage project={project} data={data} />;
+  }
   if (route.name === "feed") {
     return (
       <>
@@ -1156,6 +1359,39 @@ function ProjectSettingsPage(props: {
       </>
     );
   }
+  if (route.form === "pack-token") {
+    if (!owner) {
+      return <NothingHere />;
+    }
+    return (
+      <>
+        {head}
+        {error !== undefined && <Callout tone="danger">{error}</Callout>}
+        <section className="sc-panel sc-panel-form" aria-label={words.projects.packToken.aria}>
+          <PackTokenForm
+            set={project.packToken !== null}
+            busy={busy}
+            onSubmit={(token) =>
+              void act(async () => {
+                await data.actions.setPackToken(token);
+                navigation.replace(here);
+              })
+            }
+            onRemove={
+              project.packToken === null
+                ? undefined
+                : () =>
+                    void act(async () => {
+                      await data.actions.removePackToken();
+                      navigation.replace(here);
+                    })
+            }
+            onCancel={() => navigation.back(here)}
+          />
+        </section>
+      </>
+    );
+  }
   return (
     <>
       {head}
@@ -1191,6 +1427,24 @@ function ProjectSettingsPage(props: {
               )}
             </dd>
           </div>
+          <div>
+            <dt>{settings.packToken}</dt>
+            <dd>
+              {project.packToken === null ? (
+                <span className="sc-muted">{settings.packTokenNone}</span>
+              ) : (
+                <>
+                  {settings.packTokenSet} <Time iso={project.packToken.setAt} />
+                </>
+              )}
+              {owner && (
+                <>
+                  {" "}
+                  <a href={projectSettingsHref(key, "pack-token")}>{settings.packTokenEdit}</a>
+                </>
+              )}
+            </dd>
+          </div>
           <div>
             <dt>{form.symbol}</dt>
             <dd>
@@ -2073,6 +2327,7 @@ export function createConsole(config: ConsoleConfig = {}): ConsoleApp {
           wide={
             route.name === "board" ||
             route.name === "calendar" ||
+            (route.name === "goal" && route.form === undefined) ||
             (route.name === "custom" &&
               pages.some((candidate) => candidate.key === route.page && candidate.wide === true))
           }

package/src/data.ts

@@ -6,6 +6,8 @@ import {
   type DocumentFilter,
   EVENT_KINDS,
   type FileUpload,
+  LIST_LIMIT,
+  type ProjectClient,
   type RestAnswerInput,
   type RestCategory,
   type RestCategoryInput,
@@ -44,6 +46,7 @@ import {
   type RestTask,
   type RestTaskInput,
   type RestTaskPatch,
+  type RestTasks,
   type RestToken,
   type RestTokenCreated,
   type RestTokenInput,
@@ -74,11 +77,26 @@ export interface ConsoleActions {
   /** Sets the image for the mark of the project the page is on, or takes it away; for an owner. */
   setProjectIcon(input: FileUpload): Promise<RestProject>;
   removeProjectIcon(): Promise<RestProject>;
+  /** Sets the pack token of the project the page is on, or takes it away; for an owner (ADR-0028). */
+  setPackToken(token: string): Promise<RestProject>;
+  removePackToken(): Promise<RestProject>;
   addMember(input: RestMemberInput): Promise<RestMember>;
   updateMember(personId: string, patch: RestMemberPatch): Promise<RestMember>;
   removeMember(personId: string): Promise<void>;
   createTask(input: RestTaskInput): Promise<RestTask>;
   updateTask(id: string, patch: RestTaskPatch): Promise<RestTask>;
+  /** One task by its id or its number, asked for by itself: a task put away is not among the board's. */
+  fetchTask(ref: string, signal?: AbortSignal): Promise<RestTask>;
+  /** Puts a done or dropped task away, or brings one back (ADR-0029). */
+  archiveTask(id: string): Promise<RestTask>;
+  restoreTask(id: string): Promise<RestTask>;
+  /** Puts every done or dropped task of a goal away; for an owner. Answers how many went. */
+  archiveGoalTasks(goalId: string): Promise<number>;
+  /** A page of the tasks put away, newest first. */
+  archivedTasks(
+    page: { readonly limit: number; readonly offset: number },
+    signal?: AbortSignal,
+  ): Promise<RestTasks>;
   raiseDecision(input: RestDecisionInput): Promise<RestDecision>;
   answerDecision(id: string, input: RestAnswerInput): Promise<RestDecision>;
   /** Grows a decision's record: its context, or what followed. */
@@ -201,6 +219,32 @@ async function readFeed(
   return events.slice(-FEED_KEEP);
 }
 
+/** How many pages of the current tasks are read before the board is shown as it stands. */
+const TASKS_MAX_PAGES = 20;
+
+/**
+ * The current tasks of a project, whole: page after page while the server says there is more,
+ * so that a board past one page loses nothing without a word; the tasks put away are not among
+ * them (ADR-0029).
+ */
+async function readTasks(
+  scope: ProjectClient,
+  signal: AbortSignal | undefined,
+): Promise<{ readonly items: RestTask[] }> {
+  const items: RestTask[] = [];
+  for (let page = 0; page < TASKS_MAX_PAGES; page += 1) {
+    const result = await scope.tasks(
+      { archived: false, limit: LIST_LIMIT, offset: page * LIST_LIMIT },
+      signal,
+    );
+    items.push(...result.items);
+    if (!result.more) {
+      break;
+    }
+  }
+  return { items };
+}
+
 const wordsOf = (failure: unknown, fallback: string): string =>
   failure instanceof ApiError ? failure.message : fallback;
 
@@ -265,7 +309,7 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
       const [nextProject, nextTasks, nextDecisions, nextGoals, nextRuns, nextMembers] =
         await Promise.all([
           scope.get(signal),
-          scope.tasks(undefined, signal),
+          readTasks(scope, signal),
           scope.decisions(undefined, signal),
           scope.goals({}, signal),
           scope.runs(undefined, signal),
@@ -454,6 +498,16 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
         await refreshWorkspace();
         return changed;
       },
+      async setPackToken(token) {
+        const changed = await scope().setPackToken({ token });
+        setProject(changed);
+        return changed;
+      },
+      async removePackToken() {
+        const changed = await scope().removePackToken();
+        setProject(changed);
+        return changed;
+      },
       async addMember(input) {
         const member = await scope().addMember(input);
         await refreshProject();
@@ -478,6 +532,23 @@ export function useConsoleData(client: ConsoleClient, projectKey: string | undef
         setTasks((current) => current.map((candidate) => (candidate.id === id ? task : candidate)));
         return task;
       },
+      fetchTask: (ref, signal) => scope().task(ref, signal),
+      async archiveTask(id) {
+        const task = await scope().archiveTask(id);
+        setTasks((current) => current.filter((candidate) => candidate.id !== id));
+        return task;
+      },
+      async restoreTask(id) {
+        const task = await scope().restoreTask(id);
+        setTasks((current) => [task, ...current.filter((candidate) => candidate.id !== id)]);
+        return task;
+      },
+      async archiveGoalTasks(goalId) {
+        const { archived } = await scope().archiveTasksOfGoal(goalId);
+        await refreshProject();
+        return archived;
+      },
+      archivedTasks: (page, signal) => scope().tasks({ archived: true, ...page }, signal),
       async raiseDecision(input) {
         const decision = await scope().raiseDecision(input);
         await refreshProject();

package/src/i18n/en.ts

@@ -194,12 +194,24 @@ export const en = {
         private: "The administrators own it until an owner is listed.",
       },
     },
+    packToken: {
+      aria: "The pack token",
+      label: "Token",
+      hint: "A token a person made at SkillCDN for the pack's repository, on their account page there. The console keeps it sealed, reads the pack with it for whoever may see the project, and shows it to nobody.",
+      placeholder: "scdn_repo_…",
+      set: "Set the token",
+      remove: "Remove the token",
+    },
     settings: {
       title: "Settings",
       aria: "Project settings",
       edit: "Edit the project",
       organizationsSkills: (address: string) => `The organization's: ${address}`,
       noSkills: "None: the console names no address for the organization's.",
+      packToken: "Pack token",
+      packTokenNone: "None: a public pack needs none, and a private one is not read.",
+      packTokenSet: "Set",
+      packTokenEdit: "Change it",
     },
   },
 
@@ -210,6 +222,8 @@ export const en = {
       body: "Write the first task: what is to be done, and for whom.",
     },
     moveTo: "Move to",
+    grip: "Drag to another column",
+    archive: "Archive",
     decisions: (n: number) => count(n, "decision", "decisions"),
     decisionsTitle: "Decisions waiting for a person",
     filters: {
@@ -265,6 +279,10 @@ export const en = {
             : "",
     started: "Started",
     done: "Done",
+    archived: "Put away",
+    archivedAt: "Put away",
+    archive: "Put away",
+    restore: "Bring back",
     form: {
       title: "Title",
       titlePlaceholder: "What is to be done, in plain words that stand on their own.",
@@ -394,6 +412,12 @@ export const en = {
     setBy: "Set by",
     state: "State",
     nothingMore: "Nothing more was written about it.",
+    about: "What reaching it means",
+    archiveTasks: "Put the done tasks away",
+    archiveAsk: (n: number) =>
+      `Put the ${count(n, "task", "tasks")} done or dropped under this goal away as well?`,
+    view: "View",
+    views: { board: "Board", list: "List", calendar: "Calendar" },
     timeline: {
       title: "The months",
       legend: "Category colours",
@@ -555,6 +579,8 @@ export const en = {
       taskUpdated: (fields: string, task: string) => `changed ${fields} of ${task}`,
       taskCommented: (task: string, excerpt: string | undefined) =>
         `commented on ${task}${excerpt === undefined || excerpt === "" ? "" : `: ${excerpt}`}`,
+      taskArchived: (task: string) => `put ${task} away`,
+      taskRestored: (task: string) => `brought ${task} back`,
       decisionRaised: (question: string) => `asked: ${question}`,
       decisionAnswered: (question: string, option: string) => `answered "${question}": ${option}`,
       decisionUpdated: (fields: string, question: string) =>
@@ -575,6 +601,19 @@ export const en = {
     },
   },
 
+  archive: {
+    title: "Archive",
+    lead: "Tasks done or dropped and put away: out of the board, the lists and the calendar, each still open by its number. Brought back from here.",
+    loading: "Loading the archive",
+    empty: {
+      title: "Nothing is put away",
+      body: "A task done or dropped is put away from its page, with its goal, or by the console after a while.",
+    },
+    since: "put away",
+    restore: "Bring back",
+    more: "Show more",
+  },
+
   runs: {
     for: "for",
     since: "since",
@@ -601,6 +640,16 @@ export const en = {
     picture: (name: string) => `The picture ${name}`,
     label: (name: string) => `A comment by ${name}`,
   },
+  pictures: {
+    open: (name: string) => `Open the picture ${name}`,
+    label: (name: string) => `The picture ${name}, large`,
+    close: "Close",
+    zoomIn: "Zoom in",
+    zoomOut: "Zoom out",
+    fit: "Fit to the screen",
+    file: "Open the file itself",
+    hint: "Zoom with the wheel, the buttons or two fingers; drag to move; Escape closes.",
+  },
 
   skills: {
     loading: "Loading the skills",
@@ -612,13 +661,15 @@ export const en = {
     servedBy: "Served by",
     at: "at",
     connect:
-      "An agent reads these through its own MCP connection to this address, which a person makes once:",
+      "An agent reads these with the console command (console skill <path>), or through its own MCP connection to this address, which a person makes once:",
     connectLink: "how, on the address's page at SkillCDN",
     status: {
       indexing: "SkillCDN is still indexing the repository. Look again in a moment.",
       failed: "SkillCDN could not index the repository. What it found is on the address's page.",
       not_found:
-        "SkillCDN does not serve this address, or serves it only to someone signed in there. The address's page says which.",
+        "SkillCDN does not serve this address to the console: there is nothing there, or the pack is private and the project holds no pack token for it (Settings).",
+      token_invalid:
+        "The pack token the project holds no longer works at SkillCDN: it expired, was removed, or its maker lost the repository. An owner sets a new one on the Settings page.",
       unavailable: "SkillCDN could not be reached. The skills are as they were; look again later.",
     },
     none: {