silvermoon 0.3.0-rc.2 → 0.4.0

package/src/index.js

@@ -1,386 +0,0 @@
-import { resolve } from "node:path";
-
-import { REPOSITORY_SKILL_PATH } from "./adoption.js";
-import {
-  diagnosticProblem,
-} from "./dialogue.js";
-import { loadConfigSnapshot } from "./config.js";
-import { createCommandRun } from "./domain.js";
-import {
-  fetchPrimary,
-  indexSnapshot,
-  resolveSnapshot,
-  runGit,
-  sanitizeGitMessage,
-  worktreeSnapshot,
-} from "./git.js";
-import { createGitSnapshotFileSystem } from "./git-snapshot.js";
-import {
-  canonicalizeOutputLanguage,
-  DEFAULT_LANGUAGE,
-} from "./language.js";
-import {
-  observeSnapshot,
-  unavailableObservation,
-} from "./observation.js";
-import {
-  CONFIG_PATH,
-  GUIDANCE_ROOT,
-  IDEAS_ROOT,
-} from "./layout.js";
-
-function preloadCheckBlob({ name }) {
-  return (
-    name === CONFIG_PATH
-    || name === "package.json"
-    || name.startsWith(`${REPOSITORY_SKILL_PATH}/`)
-    || name.startsWith(`${GUIDANCE_ROOT}/`)
-    || (
-      name.startsWith(`${IDEAS_ROOT}/`)
-      && name.endsWith("/status.yaml")
-    )
-  );
-}
-
-function targetArgument({ commit, remote, staged, worktree }) {
-  if (remote) return { type: "remote" };
-  if (commit !== undefined) return { type: "commit", revision: commit };
-  if (staged) return { type: "staged" };
-  if (worktree) return { type: "worktree" };
-  return { type: "head" };
-}
-
-function failureReport({
-  runtime,
-  outputLanguage,
-  problem,
-  root,
-  version,
-}) {
-  return runtime.complete(
-    unavailableObservation({
-      outputLanguage,
-      problem,
-      root,
-      version,
-    }),
-    {},
-    { factType: "validation.failed" },
-  );
-}
-
-async function inspectTree({
-  gitRoot,
-  outputLanguage,
-  root,
-  tree,
-  userHome,
-  version,
-}) {
-  const filesystem = createGitSnapshotFileSystem({
-    gitRoot,
-    preload: preloadCheckBlob,
-    root,
-    tree,
-  });
-  return observeSnapshot({
-    contentRoot: root,
-    filesystem,
-    gitRoot,
-    outputLanguage,
-    root,
-    projectOnly: true,
-    snapshotTree: tree,
-    userHome,
-    version,
-  });
-}
-
-function finishCheck(runtime, observed) {
-  return runtime.complete(
-    observed.observation,
-    {},
-    { factType: "validation.completed" },
-  );
-}
-
-export async function checkRepository({
-  commit,
-  language,
-  remote = false,
-  root = process.cwd(),
-  staged = false,
-  userHome,
-  worktree = false,
-} = {}) {
-  const canonicalLanguage = language === undefined
-    ? undefined
-    : canonicalizeOutputLanguage(language);
-  const fallbackOutputLanguage = canonicalLanguage ?? DEFAULT_LANGUAGE;
-  const requestedRoot = resolve(root);
-  const targetCount = [remote, commit !== undefined, staged, worktree]
-    .filter(Boolean).length;
-  if (targetCount > 1) {
-    const error = new Error(
-      "Check targets are mutually exclusive; choose one of remote, commit, staged, or worktree.",
-    );
-    error.exitCode = 2;
-    throw error;
-  }
-  const target = targetArgument({ commit, remote, staged, worktree });
-  const intention = {
-    command: "check",
-    args: {
-      target,
-      language: canonicalLanguage ?? null,
-    },
-  };
-  const runtime = createCommandRun(intention);
-  const repository = runGit(requestedRoot, ["rev-parse", "--show-toplevel"]);
-  if (!repository.ok) {
-    const observed = await observeSnapshot({
-      outputLanguage: canonicalLanguage,
-      projectOnly: true,
-      root: requestedRoot,
-      userHome,
-      version: target.type === "commit" || target.type === "head"
-        ? { type: "commit", commit: null }
-        : target.type === "remote"
-          ? { type: "remote", commit: null }
-          : { type: target.type },
-    });
-    return finishCheck(runtime, observed);
-  }
-  const repositoryRoot = resolve(repository.stdout);
-
-  if (remote) {
-    let head;
-    try {
-      head = resolveSnapshot(repositoryRoot, "HEAD");
-    } catch (caught) {
-      return failureReport({
-        runtime,
-        outputLanguage: fallbackOutputLanguage,
-        problem: {
-          type: "head-unavailable",
-          summary: sanitizeGitMessage(caught.message),
-        },
-        root: repositoryRoot,
-        version: { type: "remote", commit: null },
-      });
-    }
-    let bootstrap;
-    try {
-      bootstrap = await loadConfigSnapshot({
-        gitRoot: repositoryRoot,
-        tree: head.tree,
-      });
-    } catch (caught) {
-      return failureReport({
-        runtime,
-        outputLanguage: fallbackOutputLanguage,
-        problem: {
-          type: "snapshot-inspection-failed",
-          summary: sanitizeGitMessage(caught.message),
-        },
-        root: repositoryRoot,
-        version: { type: "remote", commit: null },
-      });
-    }
-    if (!bootstrap.config) {
-      return runtime.complete({
-          state: "project-setup-required",
-          observedThrough: "version",
-          root: repositoryRoot,
-          version: { type: "remote", commit: null },
-          outputLanguage: fallbackOutputLanguage,
-          problems: bootstrap.diagnostics.map((diagnostic) =>
-            diagnosticProblem(diagnostic, fallbackOutputLanguage)
-          ),
-        });
-    }
-
-    const fetched = await runtime.performAction(
-      {
-        type: "fetch-primary",
-        repository: bootstrap.config.primaryRepository,
-        branch: bootstrap.config.primaryBranch,
-      },
-      () => ({
-        commit: fetchPrimary(repositoryRoot, bootstrap.config),
-      }),
-      (caught) => ({
-        problem: {
-          type: "primary-fetch-failed",
-          summary: sanitizeGitMessage(caught.message),
-        },
-      }),
-    );
-    if (fetched.status === "failure") {
-      return failureReport({
-        runtime,
-        outputLanguage: fallbackOutputLanguage,
-        root: repositoryRoot,
-        version: { type: "remote", commit: null },
-        problem: fetched.problem,
-      });
-    }
-    const primary = fetched.result.commit;
-    try {
-      const snapshot = resolveSnapshot(repositoryRoot, primary);
-      const observed = await inspectTree({
-        gitRoot: repositoryRoot,
-        outputLanguage: canonicalLanguage,
-        root: repositoryRoot,
-        tree: snapshot.tree,
-        userHome,
-        version: { type: "remote", commit: primary },
-      });
-      return finishCheck(runtime, observed);
-    } catch (caught) {
-      return failureReport({
-        runtime,
-        outputLanguage: fallbackOutputLanguage,
-        problem: {
-          type: "snapshot-inspection-failed",
-          summary: sanitizeGitMessage(caught.message),
-        },
-        root: repositoryRoot,
-        version: { type: "remote", commit: primary },
-      });
-    }
-  }
-
-  if (commit !== undefined || (!staged && !worktree)) {
-    const revision = commit ?? "HEAD";
-    let snapshot;
-    try {
-      snapshot = resolveSnapshot(repositoryRoot, revision);
-    } catch (caught) {
-      return failureReport({
-        runtime,
-        outputLanguage: fallbackOutputLanguage,
-        problem: {
-          type: "commit-unavailable",
-          summary: sanitizeGitMessage(caught.message),
-        },
-        root: repositoryRoot,
-        version: { type: "commit", commit: null },
-      });
-    }
-    try {
-      const observed = await inspectTree({
-        gitRoot: repositoryRoot,
-        outputLanguage: canonicalLanguage,
-        root: repositoryRoot,
-        tree: snapshot.tree,
-        userHome,
-        version: { type: "commit", commit: snapshot.commit },
-      });
-      return finishCheck(runtime, observed);
-    } catch (caught) {
-      return failureReport({
-        runtime,
-        outputLanguage: fallbackOutputLanguage,
-        problem: {
-          type: "snapshot-inspection-failed",
-          summary: sanitizeGitMessage(caught.message),
-        },
-        root: repositoryRoot,
-        version: { type: "commit", commit: snapshot.commit },
-      });
-    }
-  }
-
-  if (staged) {
-    try {
-      const snapshot = indexSnapshot(repositoryRoot);
-      const observed = await inspectTree({
-        gitRoot: repositoryRoot,
-        outputLanguage: canonicalLanguage,
-        root: repositoryRoot,
-        tree: snapshot.tree,
-        userHome,
-        version: { type: "staged" },
-      });
-      return finishCheck(runtime, observed);
-    } catch (caught) {
-      return failureReport({
-        runtime,
-        outputLanguage: fallbackOutputLanguage,
-        problem: {
-          type: "snapshot-inspection-failed",
-          summary: sanitizeGitMessage(caught.message),
-        },
-        root: repositoryRoot,
-        version: { type: "staged" },
-      });
-    }
-  }
-
-  try {
-    const snapshot = worktreeSnapshot(repositoryRoot);
-    const observed = await inspectTree({
-      gitRoot: repositoryRoot,
-      outputLanguage: canonicalLanguage,
-      root: repositoryRoot,
-      tree: snapshot.tree,
-      userHome,
-      version: { type: "worktree" },
-    });
-    return finishCheck(runtime, observed);
-  } catch (caught) {
-    return failureReport({
-      runtime,
-      outputLanguage: fallbackOutputLanguage,
-      problem: {
-        type: "snapshot-inspection-failed",
-        summary: sanitizeGitMessage(caught.message),
-      },
-      root: repositoryRoot,
-      version: { type: "worktree" },
-    });
-  }
-}
-
-export {
-  ACTIVE_IDEA_STATES,
-  deriveIdeaState,
-  IDEA_STATES,
-  isValidUlid,
-  parseIdeaStatus,
-  serializeIdeaStatus,
-  validateIdeaStatus,
-} from "./ideas.js";
-export {
-  extractIdeaTitle,
-  ideaCreatedAt,
-  ideaInventoryItem,
-  normalizeIdeaQuery,
-  queryIdeaInventory,
-} from "./idea-query.js";
-export { listIdeas } from "./list-ideas.js";
-export { createIdea, generateUlid } from "./create-idea.js";
-export {
-  inspectAdoption,
-  SILVERMOON_VERSION,
-} from "./adoption.js";
-export {
-  CommandRun,
-  DOMAIN_MESSAGE_SCHEMA_VERSION,
-  DomainInvariantError,
-  driveCommand,
-  initialInternalObservation,
-  projectActions,
-  projectIntention,
-  projectPublicObservation,
-  projectReport,
-  reduceObservation,
-  replayObservation,
-} from "./domain.js";
-export {
-  renderResponse,
-  respond,
-} from "./response.js";
-export { TRACE_SCHEMA_VERSION } from "./trace.js";
-export { whatsNext } from "./whatsnext.js";

package/src/language.js

@@ -1,78 +0,0 @@
-export const DEFAULT_LANGUAGE = "en-US";
-export const OUTPUT_LANGUAGES = Object.freeze(["en-US", "zh-CN"]);
-
-const OUTPUT_LANGUAGE_SET = new Set(OUTPUT_LANGUAGES);
-
-export function isChinese(language) {
-  return language?.toLowerCase().startsWith("zh") ?? false;
-}
-
-export function localize(language, english, chinese) {
-  return isChinese(language) ? chinese : english;
-}
-
-export function canonicalizeLanguageTag(value) {
-  if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
-    throw new Error("language tag must be a non-empty trimmed string");
-  }
-  try {
-    const [canonical] = Intl.getCanonicalLocales(value);
-    if (!canonical) throw new Error("language tag is empty");
-    return canonical;
-  } catch {
-    throw new Error(`invalid BCP 47 language tag: ${value}`);
-  }
-}
-
-export function isCanonicalLanguageTag(value) {
-  try {
-    return canonicalizeLanguageTag(value) === value;
-  } catch {
-    return false;
-  }
-}
-
-export function canonicalizeOutputLanguage(value) {
-  let canonical;
-  try {
-    canonical = canonicalizeLanguageTag(value);
-  } catch (caught) {
-    caught.exitCode = 2;
-    throw caught;
-  }
-  canonical = {
-    en: "en-US",
-    zh: "zh-CN",
-  }[canonical.toLowerCase()] ?? canonical;
-  if (!OUTPUT_LANGUAGE_SET.has(canonical)) {
-    const error = new Error(
-      `unsupported output language: ${canonical}; expected ${OUTPUT_LANGUAGES.join(" or ")}`,
-    );
-    error.exitCode = 2;
-    throw error;
-  }
-  return canonical;
-}
-
-export function resolveLanguage({ idea, project, global } = {}) {
-  if (idea !== undefined) return { tag: idea, source: "idea" };
-  if (project !== undefined) return { tag: project, source: "project" };
-  if (global !== undefined) return { tag: global, source: "global" };
-  return { tag: DEFAULT_LANGUAGE, source: "default" };
-}
-
-export function resolveOutputLanguage({ content, override } = {}) {
-  if (override !== undefined) {
-    return {
-      tag: canonicalizeOutputLanguage(override),
-      source: "override",
-    };
-  }
-  if (content?.toLowerCase().startsWith("zh")) {
-    return { tag: "zh-CN", source: "content" };
-  }
-  return {
-    tag: DEFAULT_LANGUAGE,
-    source: content === undefined ? "default" : "content",
-  };
-}

package/src/layout.js

@@ -1,38 +0,0 @@
-export const METADATA_ROOT = ".silvermoon";
-export const CONFIG_PATH = `${METADATA_ROOT}/config.yaml`;
-export const IDEAS_ROOT = `${METADATA_ROOT}/ideas`;
-export const GUIDANCE_ROOT = `${METADATA_ROOT}/guidance`;
-export const PHASE_GUIDANCE_PATHS = Object.freeze({
-  preparing: `${GUIDANCE_ROOT}/preparing.md`,
-  implementing: `${GUIDANCE_ROOT}/implementing.md`,
-  deploying: `${GUIDANCE_ROOT}/deploying.md`,
-});
-export const GUIDANCE_PHASES = Object.freeze(
-  Object.keys(PHASE_GUIDANCE_PATHS),
-);
-
-export function phaseGuidancePath(phase) {
-  const path = PHASE_GUIDANCE_PATHS[phase];
-  if (path === undefined) {
-    throw new TypeError(`Unsupported guidance phase: ${String(phase)}`);
-  }
-  return path;
-}
-
-export function ideaPaths(id) {
-  const ideaPath = `${IDEAS_ROOT}/${id}`;
-  const outerPath = `${ideaPath}/outer`;
-  const innerPath = `${outerPath}/inner`;
-  const idealPath = `${innerPath}/ideal`;
-  return {
-    ideaPath,
-    statusPath: `${ideaPath}/status.yaml`,
-    ledgerPath: `${ideaPath}/ledger.md`,
-    outerPath,
-    deploymentDocumentPath: `${outerPath}/Deployment.md`,
-    innerPath,
-    implementationDocumentPath: `${innerPath}/Implementation.md`,
-    idealPath,
-    ideaDocumentPath: `${idealPath}/Idea.md`,
-  };
-}

package/src/list-ideas.js

@@ -1,196 +0,0 @@
-import { createCommandRun } from "./domain.js";
-import {
-  ideaInventoryItem,
-  normalizeIdeaQuery,
-  queryIdeaInventory,
-} from "./idea-query.js";
-import {
-  metadataFailureObservation,
-  readIdeaInventoryItem,
-} from "./idea-metadata.js";
-import { canonicalizeOutputLanguage } from "./language.js";
-import { observeSnapshot } from "./observation.js";
-import { traceAsync } from "./trace.js";
-
-function withoutTitleQuery(query, { limit = query.limit } = {}) {
-  return { ...query, limit, query: null };
-}
-
-function matchesIdentity(item, needle) {
-  return [item.id, item.alias]
-    .filter((value) => value !== undefined)
-    .some((value) => value.toLowerCase().includes(needle));
-}
-
-async function queryObservedInventory({
-  ideas,
-  metadataReader,
-  normalizedQuery,
-  root,
-}) {
-  const ideasById = new Map(ideas.map((idea) => [idea.id, idea]));
-  const baseItems = ideas.map((idea) => ideaInventoryItem(idea));
-  const candidates = queryIdeaInventory(
-    baseItems,
-    withoutTitleQuery(normalizedQuery, { limit: null }),
-  ).ideas;
-
-  return traceAsync(
-    "ideas.inventory-metadata",
-    {
-      candidateCount: candidates.length,
-      ideaCount: ideas.length,
-    },
-    async () => {
-      const loadedItems = new Map();
-      let queryCandidateCount = 0;
-      let titleReadCount = 0;
-
-      const readItems = async (items) => {
-        const unread = items.filter(({ id }) => !loadedItems.has(id));
-        titleReadCount += unread.length;
-        const loaded = await Promise.all(unread.map(({ id }) => {
-          const idea = ideasById.get(id);
-          if (idea === undefined) {
-            throw new Error(`Missing observed idea metadata for ${id}`);
-          }
-          return metadataReader(root, idea);
-        }));
-        for (const item of loaded) loadedItems.set(item.id, item);
-      };
-
-      let matchingItems = candidates;
-      if (normalizedQuery.query !== null) {
-        const needle = normalizedQuery.query.toLowerCase();
-        const directMatchIds = new Set(
-          candidates
-            .filter((item) => matchesIdentity(item, needle))
-            .map(({ id }) => id),
-        );
-        const titleCandidates = candidates.filter(
-          ({ id }) => !directMatchIds.has(id),
-        );
-        queryCandidateCount = titleCandidates.length;
-        await readItems(titleCandidates);
-        matchingItems = candidates
-          .filter(({ id }) =>
-            directMatchIds.has(id)
-            || loadedItems.get(id)?.title?.toLowerCase().includes(needle)
-          )
-          .map((item) => loadedItems.get(item.id) ?? item);
-      }
-
-      const selected = queryIdeaInventory(
-        matchingItems,
-        withoutTitleQuery(normalizedQuery),
-      );
-      await readItems(selected.ideas);
-      const inventory = {
-        summary: selected.summary,
-        ideas: selected.ideas.map(({ id }) => {
-          const item = loadedItems.get(id);
-          if (item === undefined) {
-            throw new Error(`Missing selected idea metadata for ${id}`);
-          }
-          return item;
-        }),
-      };
-      return { inventory, queryCandidateCount, titleReadCount };
-    },
-    ({ inventory, queryCandidateCount, titleReadCount }) => ({
-      attributes: {
-        matchedCount: inventory.summary.matched,
-        queryCandidateCount,
-        returnedCount: inventory.summary.returned,
-        titleReadCount,
-      },
-    }),
-  );
-}
-
-export async function listIdeas({
-  all,
-  createdBefore,
-  createdSince,
-  language,
-  limit,
-  metadataReader = readIdeaInventoryItem,
-  query,
-  root = process.cwd(),
-  sort,
-  states,
-  userHome,
-} = {}) {
-  const canonicalLanguage = language === undefined
-    ? undefined
-    : canonicalizeOutputLanguage(language);
-  const normalizedQuery = normalizeIdeaQuery({
-    all,
-    createdBefore,
-    createdSince,
-    limit,
-    query,
-    sort,
-    states,
-  });
-  const intention = {
-    command: "list-ideas",
-    args: {
-      ...normalizedQuery,
-      language: canonicalLanguage ?? null,
-    },
-  };
-  const runtime = createCommandRun(intention);
-  const observed = await observeSnapshot({
-    root,
-    outputLanguage: canonicalLanguage,
-    userHome,
-    version: { type: "worktree" },
-  });
-  if (!observed.projectReady) {
-    return runtime.complete(
-      observed.observation,
-      { nextSteps: observed.findings.map(({ instruction }) => instruction) },
-      { factType: "ideas.inventory-unavailable" },
-    );
-  }
-
-  let queried;
-  try {
-    queried = await queryObservedInventory({
-      ideas: observed.layout.ideas,
-      metadataReader,
-      normalizedQuery,
-      root: observed.observation.root,
-    });
-  } catch (caught) {
-    const failure = metadataFailureObservation(
-      observed,
-      caught,
-      "silvermoon list-ideas",
-    );
-    return runtime.complete(
-      failure.observation,
-      failure.responseContext,
-      { factType: "ideas.inventory-unavailable" },
-    );
-  }
-
-  const { inventory } = queried;
-  const {
-    configuration,
-    outputLanguage,
-    root: repositoryRoot,
-    version,
-  } = observed.observation;
-  return runtime.complete({
-    state: "ideas-listed",
-    root: repositoryRoot,
-    version,
-    configuration,
-    outputLanguage,
-    problems: [],
-    summary: inventory.summary,
-    ideas: inventory.ideas,
-  }, {}, { factType: "ideas.listed" });
-}