Newer
Older
gnexus-book / ui / src / pages / DocsPage.vue
<script setup>
import { computed, onMounted, reactive, ref, watch } from "vue";
import { useRouter } from "vue-router";
import {
  GnAlert,
  GnButton,
  GnCard,
  GnConfirmDialog,
  GnDescriptionList,
  GnDrawer,
  GnEmptyState,
  GnInput,
  GnModal,
  GnPageHeader,
  GnSearchField,
  GnTextarea,
  useToast
} from "gnexus-ui-kit/vue";

import { apiGet, apiSend, encodePath } from "../lib/api.js";
import {
  defaultDocTemplate,
  displayValue,
  formatDate,
  readableKey,
  renderMarkdown
} from "../lib/format.js";
import { canWrite } from "../lib/session.js";
import { t } from "../i18n/index.js";

const router = useRouter();
const toast = useToast();

const docs = ref([]);
const listError = ref("");
const docQuery = ref("");
const searchResults = ref([]);
const searching = ref(false);
const selectedDocPath = ref("");
const selectedDoc = ref(null);
const docLoading = ref(false);
const docError = ref("");
const docHistory = ref([]);
const historyError = ref("");
const docDiff = ref("");
const diffError = ref("");
const mobileDocView = ref("list");
const historyOpen = ref(false);
const proposalOpen = ref(false);
const proposalRunning = ref(false);
const proposal = reactive({
  target: "",
  summary: "",
  reason: "",
  content: defaultDocTemplate()
});
const confirmState = reactive({
  open: false,
  title: "",
  message: "",
  confirmText: "",
  variant: "warning",
  action: null
});
let searchTimer = null;

const docFrontmatterItems = computed(() => {
  const frontmatter = selectedDoc.value?.frontmatter || {};
  const priority = [
    "owner",
    "status",
    "last_reviewed",
    "review_interval",
    "confidence",
    "source_of_truth"
  ];
  return Object.keys(frontmatter)
    .sort((a, b) => {
      const ai = priority.indexOf(a);
      const bi = priority.indexOf(b);
      if (ai === -1 && bi === -1) return a.localeCompare(b);
      if (ai === -1) return 1;
      if (bi === -1) return -1;
      return ai - bi;
    })
    .map(key => ({ key, term: readableKey(key), value: displayValue(frontmatter[key]) }));
});

const renderedDocBody = computed(() => renderMarkdown(selectedDoc.value?.body || ""));

const isLatestVersion = versionNo => {
  if (!docHistory.value.length) return false;
  return versionNo === Math.max(...docHistory.value.map(version => version.version_no));
};

async function loadDocs() {
  listError.value = "";
  try {
    docs.value = (await apiGet("/docs")) || [];
    if (selectedDocPath.value && docs.value.some(doc => doc.path === selectedDocPath.value)) {
      await loadDoc(selectedDocPath.value, mobileDocView.value === "detail");
    } else if (docs.value.length) {
      await loadDoc(docs.value[0].path, false);
    }
  } catch (error) {
    listError.value = error instanceof Error ? error.message : t("errors.loadFailed");
  }
}

async function loadDoc(path, openDetail = true) {
  if (!path) return;
  if (docQuery.value) docQuery.value = "";
  selectedDocPath.value = path;
  if (openDetail) mobileDocView.value = "detail";
  selectedDoc.value = null;
  docLoading.value = true;
  docError.value = "";
  docHistory.value = [];
  historyError.value = "";
  docDiff.value = "";
  diffError.value = "";
  try {
    selectedDoc.value = await apiGet(`/docs/read?path=${encodeURIComponent(path)}`);
    try {
      docHistory.value = await apiGet(`/documents/${encodePath(path)}/history`);
    } catch {
      historyError.value = t("docs.noHistory");
    }
  } catch (error) {
    docError.value = error instanceof Error ? error.message : t("errors.loadFailed");
  } finally {
    docLoading.value = false;
  }
}

function backToDocList() {
  mobileDocView.value = "list";
}

async function requestDiff(fromVersion, toVersion) {
  docDiff.value = "";
  diffError.value = "";
  if (!selectedDocPath.value) return;
  try {
    const data = await apiGet(
      `/documents/${encodePath(selectedDocPath.value)}/diff?from=${fromVersion}&to=${toVersion}`
    );
    docDiff.value = data.diff || "";
    if (!docDiff.value) diffError.value = t("docs.noDiff");
  } catch (error) {
    diffError.value = error instanceof Error ? error.message : t("errors.loadFailed");
  }
}

async function loadDiffFrom(versionNo) {
  const latest = docHistory.value.length
    ? Math.max(...docHistory.value.map(version => version.version_no))
    : versionNo;
  await requestDiff(versionNo, latest);
}

async function loadLatestDiff() {
  if (!docHistory.value.length) return;
  const latest = Math.max(...docHistory.value.map(version => version.version_no));
  await requestDiff(Math.max(1, latest - 1), latest);
  historyOpen.value = true;
}

function openHistory() {
  historyOpen.value = true;
}

function openProposal() {
  if (!selectedDoc.value) return;
  proposal.target = selectedDocPath.value;
  proposal.content =
    selectedDoc.value.raw || selectedDoc.value.body || defaultDocTemplate();
  proposal.summary = "";
  proposal.reason = "";
  proposalOpen.value = true;
}

async function submitProposal() {
  if (!proposal.summary.trim() || !proposal.target.trim() || !proposal.content.trim()) {
    toast.warning({ title: t("common.error"), text: t("docs.proposalMeta") });
    return;
  }
  proposalRunning.value = true;
  try {
    const created = await apiSend("/changes", "POST", {
      kind: "doc",
      target: proposal.target.trim(),
      summary: proposal.summary.trim(),
      reason: proposal.reason.trim(),
      payload: { content: proposal.content }
    });
    toast.success({ title: t("docs.proposalCreated"), text: created.target || created.id });
    proposalOpen.value = false;
    router.push("/changes");
  } catch (error) {
    toast.danger({
      title: t("errors.actionFailed"),
      text: error instanceof Error ? error.message : t("errors.actionFailed")
    });
  } finally {
    proposalRunning.value = false;
  }
}

function askConfirm({ title, message, confirmText, variant, action }) {
  confirmState.title = title;
  confirmState.message = message;
  confirmState.confirmText = confirmText;
  confirmState.variant = variant || "warning";
  confirmState.action = action || null;
  confirmState.open = true;
}

function runConfirm() {
  const action = confirmState.action;
  confirmState.action = null;
  if (action) action();
}

function restoreVersion(versionNo) {
  askConfirm({
    title: t("docs.restoreConfirm"),
    message: t("docs.restoreConfirmText", { version: versionNo }),
    confirmText: t("docs.restore"),
    variant: "warning",
    action: async () => {
      try {
        await apiSend(
          `/documents/${encodePath(selectedDocPath.value)}/restore/${versionNo}?summary=${encodeURIComponent(
            `${t("docs.restoreConfirm")} ${versionNo}`
          )}`,
          "POST"
        );
        toast.success({ title: t("docs.restored") });
        await loadDoc(selectedDocPath.value);
      } catch (error) {
        toast.danger({
          title: t("errors.actionFailed"),
          text: error instanceof Error ? error.message : t("errors.actionFailed")
        });
      }
    }
  });
}

watch(docQuery, value => {
  window.clearTimeout(searchTimer);
  const query = value.trim();
  if (!query) {
    searchResults.value = [];
    searching.value = false;
    return;
  }
  searching.value = true;
  searchTimer = window.setTimeout(async () => {
    try {
      searchResults.value = await apiGet(`/search?q=${encodeURIComponent(query)}`);
    } catch (error) {
      toast.danger({
        title: t("errors.loadFailed"),
        text: error instanceof Error ? error.message : t("errors.loadFailed")
      });
    } finally {
      searching.value = false;
    }
  }, 300);
});

onMounted(loadDocs);
</script>

<template>
  <div class="gnb-page">
    <GnPageHeader
      :title="t('docs.title')"
      :subtitle="t('docs.subtitle')"
      :kicker="t('app.kicker')"
      accent
    >
      <template #actions>
        <GnButton variant="secondary" icon="ph-arrow-clockwise" @click="loadDocs">
          {{ t("common.refresh") }}
        </GnButton>
      </template>
    </GnPageHeader>

    <GnAlert v-if="listError" variant="danger">{{ listError }}</GnAlert>

    <div class="gnb-docs-layout">
      <aside class="gnb-doc-list gnb-panel" :class="{ 'is-mobile-hidden': mobileDocView === 'detail' }">
        <div class="gnb-panel-head">
          <span class="gnb-panel-title">{{ t("docs.index") }}</span>
          <span class="gnb-muted">{{ docs.length }}</span>
        </div>
        <GnSearchField v-model="docQuery" :placeholder="t('docs.searchPlaceholder')" />
        <div v-if="docQuery.trim()" class="gnb-list-body">
          <p v-if="searching" class="gnb-muted">{{ t("common.loading") }}…</p>
          <GnEmptyState v-else-if="!searchResults.length" :title="t('docs.noResults')" icon="ph-magnifying-glass" />
          <button
            v-for="result in searchResults"
            :key="result.path"
            type="button"
            class="gnb-doc-row"
            @click="loadDoc(result.path)"
          >
            <strong>{{ result.title }}</strong>
            <span>{{ result.path }}</span>
            <small v-for="match in result.matches" :key="result.path + '-' + match.line">
              {{ match.line }}: {{ match.text }}
            </small>
          </button>
        </div>
        <div v-else class="gnb-list-body">
          <GnEmptyState v-if="!docs.length" :title="t('docs.noDocs')" icon="ph-files" />
          <button
            v-for="doc in docs"
            :key="doc.path"
            type="button"
            class="gnb-doc-row"
            :class="{ 'is-active': doc.path === selectedDocPath }"
            @click="loadDoc(doc.path)"
          >
            <strong>{{ doc.title }}</strong>
            <span>{{ doc.path }}</span>
          </button>
        </div>
      </aside>

      <section class="gnb-doc-detail" :class="{ 'is-mobile-hidden': mobileDocView === 'list' }">
        <div class="gnb-doc-toolbar">
          <GnButton class="gnb-mobile-back" size="sm" variant="secondary" icon="ph-arrow-left" @click="backToDocList">
            {{ t("common.back") }}
          </GnButton>
          <div class="gnb-doc-heading">
            <span class="gnb-doc-kicker">{{ t("docs.document") }}</span>
            <h2>{{ selectedDoc?.path || t("docs.select") }}</h2>
          </div>
          <div class="gnb-actions">
            <GnButton v-if="selectedDoc" size="sm" variant="secondary" icon="ph-clock-counter-clockwise" @click="openHistory">
              {{ t("common.history") }}
            </GnButton>
            <GnButton v-if="selectedDoc" size="sm" variant="secondary" icon="ph-git-diff" @click="loadLatestDiff">
              {{ t("common.diff") }}
            </GnButton>
            <GnButton v-if="selectedDoc && canWrite" size="sm" variant="accent" icon="ph-plus" @click="openProposal">
              {{ t("docs.newDraft") }}
            </GnButton>
          </div>
        </div>

        <GnAlert v-if="docError" variant="danger">{{ docError }}</GnAlert>
        <GnEmptyState v-else-if="!selectedDoc" :title="t('docs.select')" icon="ph-file-text" />
        <div v-else class="gnb-doc">
          <GnCard v-if="docFrontmatterItems.length" :title="t('docs.metadata')">
            <GnDescriptionList :items="docFrontmatterItems" />
          </GnCard>
          <GnCard :title="t('docs.body')" class="gnb-doc-body-card">
            <div class="gnb-markdown" v-html="renderedDocBody"></div>
          </GnCard>
          <GnAlert v-if="diffError" variant="warning">{{ diffError }}</GnAlert>
        </div>
      </section>
    </div>

    <GnDrawer v-model:open="historyOpen" :title="t('common.history')" position="right">
      <div class="gnb-history-drawer">
        <p v-if="historyError" class="gnb-muted">{{ historyError }}</p>
        <GnEmptyState v-else-if="!docHistory.length" :title="t('docs.noHistory')" icon="ph-clock" />
        <div v-else class="gnb-history">
          <div v-for="version in docHistory" :key="version.version_no" class="gnb-history-row">
            <button type="button" class="gnb-doc-row" @click="loadDiffFrom(version.version_no)">
              <strong>v{{ version.version_no }} · {{ version.summary || t("common.unknown") }}</strong>
              <span>
                {{ version.actor_kind }} / {{ version.actor_name || "—" }} · {{ version.via }} ·
                {{ formatDate(version.created_at) }}
              </span>
            </button>
            <GnButton
              v-if="canWrite && !isLatestVersion(version.version_no)"
              size="sm"
              variant="secondary"
              icon="ph-arrow-counter-clockwise"
              @click="restoreVersion(version.version_no)"
            >
              {{ t("docs.restore") }}
            </GnButton>
          </div>
        </div>
        <div v-if="docDiff" class="gnb-diff">
          <div class="gnb-drawer-section-head">
            <span>{{ t("docs.diffTitle") }}</span>
            <GnButton size="sm" variant="secondary" @click="docDiff = ''">{{ t("common.close") }}</GnButton>
          </div>
          <pre class="gnb-pre">{{ docDiff }}</pre>
        </div>
        <GnAlert v-else-if="diffError" variant="warning">{{ diffError }}</GnAlert>
      </div>
    </GnDrawer>

    <GnModal v-model:open="proposalOpen" :title="t('docs.proposalTitle')">
      <p class="gnb-muted">{{ t("docs.proposalMeta") }}</p>
      <div class="gnb-form">
        <GnInput v-model="proposal.summary" :label="t('common.summary')" icon="ph-note-pencil" />
        <GnInput v-model="proposal.target" :label="t('common.target')" icon="ph-file-md" :placeholder="t('docs.targetPlaceholder')" />
        <GnInput v-model="proposal.reason" :label="t('common.reason')" icon="ph-question" />
        <GnTextarea
          v-model="proposal.content"
          :label="t('common.content')"
          :rows="14"
          class="gnb-textarea"
          :placeholder="t('docs.contentPlaceholder')"
        />
        <div class="gnb-actions">
          <GnButton variant="success" icon="ph-plus" :loading="proposalRunning" :disabled="!canWrite" @click="submitProposal">
            {{ t("docs.submit") }}
          </GnButton>
          <GnButton variant="secondary" @click="proposalOpen = false">{{ t("common.cancel") }}</GnButton>
        </div>
      </div>
    </GnModal>

    <GnConfirmDialog
      v-model:open="confirmState.open"
      :title="confirmState.title"
      :message="confirmState.message"
      :confirm-text="confirmState.confirmText || t('common.confirm')"
      :cancel-text="t('common.cancel')"
      :confirm-variant="confirmState.variant"
      @confirm="runConfirm"
      @cancel="confirmState.action = null"
    />
  </div>
</template>