fuli-context 0.2.0

package/src/app/create-application.js

@@ -0,0 +1,143 @@
+import { assertStorePort } from '../storage/store-port.js';
+import { AgentCandidateReadService } from '../agent/candidate-read-service.js';
+import { AgentContextPackService } from '../agent/context-pack-service.js';
+import { AgentPublicReadService } from '../agent/public-read-service.js';
+import { AgentSearchService } from '../agent/search-service.js';
+import { ContextRouter } from '../router.js';
+import { IngestionService } from '../ingestion.js';
+import { observeGitDiff } from '../observer.js';
+import { decideCandidate } from '../candidates.js';
+import { buildContextPack } from '../context-pack.js';
+import { FactService } from '../facts/fact-service.js';
+import { ApplicationError, ApplicationErrorCode } from './application-error.js';
+import { StateService } from './state-service.js';
+import { bootstrapStarterSpaces } from './bootstrap.js';
+import { LensService } from '../lens/lens-service.js';
+import { LensQuery } from '../lens/lens-query.js';
+import { LensResourceService } from '../lens/lens-resource-service.js';
+import { PublicationService } from '../publication/publication-service.js';
+import { OutboxService } from '../publication/outbox-service.js';
+
+const CANDIDATE_DECISIONS = new Set(['sync', 'personal_only', 'ignore']);
+
+export function createApplication({ store, activePersonalSpaceName = '我' }) {
+  assertStorePort(store);
+  const facts = new FactService(store);
+  const lensService = new LensService(store);
+  const lensQuery = new LensQuery(store);
+  const publicationService = new PublicationService(store);
+  const outboxService = new OutboxService(store);
+  const ingestion = new IngestionService(store, {
+    facts,
+    lens: lensService,
+    publication: publicationService
+  });
+  const context = new ContextRouter(store);
+  const state = new StateService(store);
+  const agentReads = new AgentPublicReadService(store);
+  const agentSearch = new AgentSearchService(store, lensQuery);
+  const agentCandidates = new AgentCandidateReadService(store);
+  const agentContextPack = new AgentContextPackService(
+    store,
+    agentReads,
+    agentSearch,
+    agentCandidates
+  );
+  const applyCandidateDecision = (candidateId, decision) => {
+    if (!CANDIDATE_DECISIONS.has(decision)) {
+      throw new ApplicationError(
+        ApplicationErrorCode.VALIDATION,
+        `Unknown candidate decision: ${decision}`
+      );
+    }
+    if (!store.getCandidate(candidateId)) {
+      throw new ApplicationError(
+        ApplicationErrorCode.NOT_FOUND,
+        `Candidate not found: ${candidateId}`
+      );
+    }
+    return decideCandidate(store, candidateId, decision, { ingestion });
+  };
+  const lens = Object.freeze({
+    rememberUserFact: (input) => lensService.rememberUserFact(input),
+    submitUserObservation: (input) => lensService.submitUserObservation(input),
+    confirmObservation: (input) => lensService.confirmObservation(input),
+    correctUserFact: (input) => lensService.correctUserFact(input),
+    getUserLens: (input) => lensQuery.getUserLens(input),
+    getUserLensView: (input) => lensQuery.getUserLensView(input),
+    searchUserContext: (input) => lensQuery.searchUserContext(input)
+  });
+  const lensResourceService = new LensResourceService({
+    store,
+    lens,
+    activePersonalSpace: () => requireActivePersonalSpace(store, activePersonalSpaceName)
+  });
+  const publication = Object.freeze({
+    prepare: (input) => publicationService.prepare(input),
+    verify: (envelope) => publicationService.verify(envelope),
+    pending: (at) => outboxService.pending(at),
+    markFailed: (id, error) => outboxService.markFailed(id, error),
+    markSent: (id) => outboxService.markSent(id)
+  });
+  const lensResources = Object.freeze({
+    current: () => lensResourceService.current(),
+    history: () => lensResourceService.history(),
+    subscribed: () => lensResourceService.subscribed()
+  });
+  const agent = Object.freeze({
+    remember: (input) => ingestion.remember(input),
+    search: (input) => agentSearch.search(input),
+    currentFacts: (spaceId) => agentReads.currentFacts(spaceId),
+    timeline: (spaceId, subject) => agentReads.timeline(spaceId, subject),
+    projectRules: (spaceId) => agentReads.projectRules(spaceId),
+    factHistory: (input) => agentReads.factHistory(input),
+    contextPack: (input) => agentContextPack.build(input),
+    observe: (input) => observeGitDiff({ store, ...input }),
+    listCandidates: (personalSpaceId) => agentCandidates.list(personalSpaceId),
+    decideCandidate: applyCandidateDecision
+  });
+
+  return {
+    bootstrap: () => bootstrapStarterSpaces(store),
+    createSpace: (name, kind, description = null) =>
+      store.createSpace(name, kind, description),
+    resolveSpace: ({ id, name } = {}) => {
+      if (id) return store.getSpace(id);
+      return name ? store.findSpaceByName(name) : null;
+    },
+    requireSpaceId: ({ id, name, label }) => {
+      const space = id ? store.getSpace(id) : (name ? store.findSpaceByName(name) : null);
+      if (space) return space.id;
+      throw new ApplicationError(
+        ApplicationErrorCode.NOT_FOUND,
+        `${label} not found: ${name || id || 'missing'}`
+      );
+    },
+    subscribe: (personalSpaceId, spaceId, mode = 'latest') =>
+      store.subscribe(personalSpaceId, spaceId, mode),
+    remember: agent.remember,
+    agent,
+    lens,
+    lensResources,
+    publication,
+    observe: agent.observe,
+    decideCandidate: agent.decideCandidate,
+    search: (input) => context.searchContext(input),
+    contextPack: (input) => buildContextPack(store, input),
+    state: () => state.build(),
+    activePersonalSpace: () => requireActivePersonalSpace(store, activePersonalSpaceName),
+    requireActivePersonalSpace: () => requireActivePersonalSpace(store, activePersonalSpaceName),
+    close: () => store.close()
+  };
+}
+
+function requireActivePersonalSpace(store, name) {
+  const space = store.findSpaceByName(name);
+  if (!space || space.kind !== 'personal') {
+    throw new ApplicationError(
+      ApplicationErrorCode.NOT_FOUND,
+      `Active personal space not found: ${name}`
+    );
+  }
+  return space;
+}

package/src/app/state-service.js

@@ -0,0 +1,38 @@
+import { enrichCandidate } from '../candidates.js';
+
+export class StateService {
+  constructor(store) {
+    this.store = store;
+  }
+
+  build() {
+    const spaces = this.store.listSpaces();
+    const currentFacts = spaces.flatMap((space) =>
+      this.store.currentFacts(space.id).map((fact) => this.#enrichFact(fact))
+    );
+    const historicalFacts = this.store
+      .listFacts({ includeHistorical: true })
+      .filter((fact) => fact.invalidAt)
+      .map((fact) => this.#enrichFact(fact));
+    const candidates = this.store.listCandidates().map((candidate) =>
+      enrichCandidate(this.store, candidate)
+    );
+
+    return {
+      spaces,
+      subscriptions: this.store.listSubscriptions(),
+      episodes: this.store.listEpisodes(),
+      currentFacts,
+      historicalFacts,
+      candidates
+    };
+  }
+
+  #enrichFact(fact) {
+    return {
+      ...fact,
+      spaceName: this.store.getSpace(fact.spaceId)?.name ?? fact.spaceId,
+      episode: this.store.getEpisode(fact.sourceEpisodeId)
+    };
+  }
+}

package/src/candidates.js

@@ -0,0 +1,78 @@
+import { IngestionService } from './ingestion.js';
+import { ApplicationError, ApplicationErrorCode } from './app/application-error.js';
+import { CandidateStatus } from './models.js';
+
+export function listCandidates(store, personalSpaceId) {
+  return store.pendingCandidates(personalSpaceId).map((candidate) => enrichCandidate(store, candidate));
+}
+
+export function decideCandidate(store, candidateId, decision, { ingestion = new IngestionService(store) } = {}) {
+  return store.transaction(
+    () => decideCandidateInCurrentTransaction(store, candidateId, decision, ingestion),
+    { mode: 'immediate' }
+  );
+}
+
+function decideCandidateInCurrentTransaction(store, candidateId, decision, ingestion) {
+  const candidate = store.getCandidate(candidateId);
+  if (!candidate) {
+    throw new Error(`Candidate not found: ${candidateId}`);
+  }
+  if (candidate.status !== CandidateStatus.PENDING) {
+    throw new ApplicationError(
+      ApplicationErrorCode.VALIDATION,
+      `Candidate already decided: ${candidateId}`
+    );
+  }
+
+  if (decision === 'sync') {
+    if (!candidate.targetSpaceId) {
+      throw new ApplicationError(
+        ApplicationErrorCode.VALIDATION,
+        'Syncing a candidate requires a target space'
+      );
+    }
+    const episode = episodeFor(store, candidate);
+    if (episode) {
+      ingestion.publishConfirmedInCurrentTransaction({
+        targetSpaceId: candidate.targetSpaceId,
+        sourceKind: episode.sourceKind,
+        body: episode.body,
+        sourceUri: episode.sourceUri
+      });
+    }
+    return store.updateCandidateStatus(candidate.id, CandidateStatus.SYNCED);
+  }
+
+  if (decision === 'personal_only') {
+    const episode = episodeFor(store, candidate);
+    if (episode) {
+      ingestion.confirmEpisodeInCurrentTransaction({
+        spaceId: candidate.personalSpaceId,
+        episode
+      });
+    }
+    return store.updateCandidateStatus(candidate.id, CandidateStatus.PERSONAL_ONLY);
+  }
+
+  if (decision === 'ignore') {
+    return store.updateCandidateStatus(candidate.id, CandidateStatus.IGNORED);
+  }
+
+  throw new Error(`Unknown candidate decision: ${decision}`);
+}
+
+export function enrichCandidate(store, candidate) {
+  return {
+    ...candidate,
+    personalSpaceName: store.getSpace(candidate.personalSpaceId)?.name ?? candidate.personalSpaceId,
+    targetSpaceName: candidate.targetSpaceId
+      ? store.getSpace(candidate.targetSpaceId)?.name ?? candidate.targetSpaceId
+      : null,
+    episode: episodeFor(store, candidate)
+  };
+}
+
+function episodeFor(store, candidate) {
+  return store.getEpisode(candidate.episodeId);
+}

package/src/classifier.js

@@ -0,0 +1,63 @@
+import { PublishRoute } from './models.js';
+
+const PUBLIC_SOURCE_KINDS = new Set(['prd', 'git', 'config', 'docs']);
+const PERSONAL_SOURCE_KINDS = new Set(['personal']);
+const PERSONAL_MARKERS = [
+  '我觉得',
+  '我认为',
+  '我希望',
+  '我想',
+  '我打算',
+  '我更喜欢',
+  '我喜欢',
+  '我不喜欢',
+  '我的',
+  '个人',
+  '偏好',
+  '判断'
+];
+const UNCERTAIN_MARKERS = ['可能', '也许', '不确定', '待确认', '以后要', '似乎'];
+
+export function classifyEpisode({ sourceKind, body }) {
+  if (PERSONAL_SOURCE_KINDS.has(sourceKind)) {
+    return PublishRoute.PERSONAL;
+  }
+
+  if (hasAny(body, PERSONAL_MARKERS)) {
+    return PublishRoute.PERSONAL;
+  }
+
+  if (hasAny(body, UNCERTAIN_MARKERS)) {
+    return PublishRoute.CANDIDATE;
+  }
+
+  if (PUBLIC_SOURCE_KINDS.has(sourceKind) && looksLikeFact(body)) {
+    return PublishRoute.PUBLIC;
+  }
+
+  return PublishRoute.CANDIDATE;
+}
+
+function looksLikeFact(body) {
+  return (
+    body.includes(':') ||
+    body.includes('：') ||
+    body.includes('=>') ||
+    /https?:\/\//.test(body) ||
+    looksLikeForbiddenRule(body)
+  );
+}
+
+function looksLikeForbiddenRule(body) {
+  return body
+    .split(/\r?\n/)
+    .some((line) =>
+      /^(?:这个项目|本项目|项目)?\s*(?:禁止|不要|不允许)\s*(?:使用|采用|引入|用)?\s*\S+/.test(
+        line.trim()
+      )
+    );
+}
+
+function hasAny(body, markers) {
+  return markers.some((marker) => body.includes(marker));
+}

package/src/cli/command-arguments.js

@@ -0,0 +1,14 @@
+export function option(args, flag) {
+  const index = args.indexOf(flag);
+  return index === -1 ? null : args[index + 1];
+}
+
+export function requireSpace(app, name) {
+  const space = app.resolveSpace({ name });
+  if (!space) throw new Error(`Space not found: ${name}`);
+  return space;
+}
+
+export function humanPredicate(predicate) {
+  return predicate.startsWith('has_') ? predicate.slice(4) : predicate;
+}

package/src/cli/command-registry.js

@@ -0,0 +1,78 @@
+import { candidate, candidates } from './commands/candidates.js';
+import { observe, remember } from './commands/ingestion.js';
+import { context, history, rules, search, timeline } from './commands/reads.js';
+import { createSpace, subscribe } from './commands/spaces.js';
+
+const COMMANDS = Object.freeze({
+  space: createSpace,
+  subscribe,
+  remember,
+  observe,
+  search,
+  timeline,
+  rules,
+  history,
+  context,
+  candidates,
+  candidate
+});
+
+const LOCAL_RUNTIME_COMMANDS = new Set(['start', 'stop', 'restart', 'status', 'open']);
+
+export function dispatchCommand(app, command, args) {
+  const handler = COMMANDS[command];
+  if (!handler) throw new Error(`Unknown command: ${command}`);
+  return handler(app, args);
+}
+
+export function isRegisteredCommand(command) {
+  return command === '--help' || command === '-h' ||
+    command === '--version' || command === '-v' ||
+    Object.hasOwn(COMMANDS, command);
+}
+
+export function isCliCommand(command) {
+  return command === 'setup' || command === 'uninstall' || command === 'migrate' ||
+    LOCAL_RUNTIME_COMMANDS.has(command) || isRegisteredCommand(command);
+}
+
+export function isLocalRuntimeCommand(command) {
+  return LOCAL_RUNTIME_COMMANDS.has(command);
+}
+
+export function printHelp() {
+  console.log(`fl <command>
+
+General:
+  --help, -h
+  --version, -v
+
+Local service:
+  start [--port 2727] [--open] [--rebuild] [--data-dir DIR]
+  stop [--data-dir DIR]
+  restart [--port 2727] [--open] [--rebuild] [--data-dir DIR]
+  status [--json] [--data-dir DIR]
+  open [--data-dir DIR]
+
+Install and Agent connection:
+  setup [--yes] [--codex-only] [--data-dir DIR] [--personal-space NAME] [--port PORT] [--skip-agents] [--no-start] [--with-dev-public]
+  uninstall [--yes] [--data-dir DIR]
+
+Legacy local knowledge commands:
+  fl [--db SQLITE_DB] [--personal-space 我] <command>
+  Global options must appear before the command.
+
+Commands:
+  space create NAME --kind personal|public
+  subscribe PERSONAL_SPACE PUBLIC_SPACE
+  remember PERSONAL_SPACE --target SPACE --source-kind prd --text TEXT
+  observe PERSONAL_SPACE --target SPACE
+  search PERSONAL_SPACE QUERY
+  timeline SPACE SUBJECT
+  rules SPACE
+  history SPACE PREDICATE
+  context PERSONAL_SPACE SPACE QUERY
+  candidates PERSONAL_SPACE
+  candidate CANDIDATE_ID sync|personal_only|ignore
+  migrate --from LEGACY_JSON --to SQLITE_DB`);
+}

package/src/cli/commands/candidates.js

@@ -0,0 +1,17 @@
+import { requireSpace } from '../command-arguments.js';
+
+export function candidates(app, args) {
+  const personal = requireSpace(app, args[0]);
+  const pending = app.agent.listCandidates(personal.id);
+  console.log(pending.map((candidate) => `${candidate.id} ${candidate.reason ?? ''}`.trim())
+    .join('\n'));
+}
+
+export function candidate(app, args) {
+  const [candidateId, decision] = args;
+  if (!candidateId || !decision) {
+    throw new Error('Usage: candidate CANDIDATE_ID sync|personal_only|ignore');
+  }
+  const result = app.decideCandidate(candidateId, decision);
+  console.log(`candidate ${result.status} ${result.id}`);
+}

package/src/cli/commands/ingestion.js

@@ -0,0 +1,32 @@
+import { option, requireSpace } from '../command-arguments.js';
+
+export function remember(app, args) {
+  const [personalName, ...rest] = args;
+  const personal = requireSpace(app, personalName);
+  const targetName = option(rest, '--target');
+  const target = targetName ? requireSpace(app, targetName) : null;
+  const body = option(rest, '--text');
+  if (!body) throw new Error('remember requires --text');
+
+  const result = app.remember({
+    personalSpaceId: personal.id,
+    targetSpaceId: target?.id ?? null,
+    sourceKind: option(rest, '--source-kind') ?? 'agent',
+    body
+  });
+  console.log(`remembered ${result.route}`);
+}
+
+export function observe(app, args) {
+  const [personalName, ...rest] = args;
+  const personal = requireSpace(app, personalName);
+  const targetName = option(rest, '--target');
+  const target = targetName ? requireSpace(app, targetName) : null;
+  const result = app.observe({
+    personalSpaceId: personal.id,
+    targetSpaceId: target?.id ?? null,
+    cwd: option(rest, '--cwd') ?? process.cwd()
+  });
+  const suffix = result.observed.length === 1 ? 'change' : 'changes';
+  console.log(`observed ${result.observed.length} ${suffix}`);
+}

package/src/cli/commands/reads.js

@@ -0,0 +1,50 @@
+import { formatContextPack } from '../../context-pack.js';
+import { humanPredicate, requireSpace } from '../command-arguments.js';
+
+export function search(app, args) {
+  const [personalName, ...queryParts] = args;
+  const personal = requireSpace(app, personalName);
+  console.log(app.search({
+    personalSpaceId: personal.id,
+    query: queryParts.join(' ')
+  }).answer);
+}
+
+export function timeline(app, args) {
+  const [spaceName, ...subjectParts] = args;
+  const space = requireSpace(app, spaceName);
+  const facts = app.agent.timeline(space.id, subjectParts.join(' ') || space.name);
+  console.log(facts.map((fact) =>
+    `${fact.validAt} ${fact.predicate} ${fact.object}`).join('\n'));
+}
+
+export function rules(app, args) {
+  const space = requireSpace(app, args[0]);
+  const result = app.agent.projectRules(space.id);
+  const lines = [
+    ...result.forbidden.map((fact) => `forbids ${fact.object}`),
+    ...result.parameters.map((fact) => `${humanPredicate(fact.predicate)} ${fact.object}`),
+    ...result.links.map((fact) => `url ${fact.object}`)
+  ];
+  console.log(lines.join('\n'));
+}
+
+export function history(app, args) {
+  const [spaceName, predicate] = args;
+  const space = requireSpace(app, spaceName);
+  const result = app.agent.factHistory({ spaceId: space.id, predicate });
+  console.log(result.facts.map((fact) =>
+    `${fact.current ? 'current' : 'historical'} ` +
+    `${humanPredicate(fact.predicate)} ${fact.object}`).join('\n'));
+}
+
+export function context(app, args) {
+  const [personalName, spaceName, ...queryParts] = args;
+  const personal = requireSpace(app, personalName);
+  const space = requireSpace(app, spaceName);
+  console.log(formatContextPack(app.agent.contextPack({
+    personalSpaceId: personal.id,
+    spaceId: space.id,
+    query: queryParts.join(' ')
+  })));
+}

package/src/cli/commands/spaces.js

@@ -0,0 +1,20 @@
+import { SpaceKind } from '../../models.js';
+import { option, requireSpace } from '../command-arguments.js';
+
+export function createSpace(app, args) {
+  const [subcommand, name, ...rest] = args;
+  if (subcommand !== 'create') {
+    throw new Error('Usage: space create NAME --kind personal|public');
+  }
+  const kind = option(rest, '--kind') ?? SpaceKind.PUBLIC;
+  const space = app.createSpace(name, kind);
+  console.log(`${space.name} ${space.kind} ${space.id}`);
+}
+
+export function subscribe(app, args) {
+  const [personalName, spaceName] = args;
+  const personal = requireSpace(app, personalName);
+  const space = requireSpace(app, spaceName);
+  app.subscribe(personal.id, space.id);
+  console.log(`${personal.name} subscribed ${space.name}`);
+}

package/src/cli/invocation.js

@@ -0,0 +1,47 @@
+import { isCliCommand } from './command-registry.js';
+
+const RUNTIME_FLAGS = new Set(['--db', '--personal-space']);
+
+export function parseCliInvocation(argv = []) {
+  const { runtimeArgs, commandArgs } = splitRuntimePrefix(argv);
+  const [command, ...args] = commandArgs;
+  return { runtimeArgs, command, args };
+}
+
+export function splitRuntimePrefix(argv = []) {
+  const runtimeArgs = [];
+  let index = 0;
+  while (index < argv.length && RUNTIME_FLAGS.has(argv[index])) {
+    const flag = argv[index];
+    const value = argv[index + 1];
+    if (!isRuntimeValue(value, argv, index + 2)) {
+      throw new TypeError(`Missing value for ${flag}`);
+    }
+    runtimeArgs.push(flag, value);
+    index += 2;
+  }
+  return { runtimeArgs, commandArgs: argv.slice(index) };
+}
+
+function isRuntimeValue(value, argv, nextIndex) {
+  if (!isPlainValue(value)) return false;
+  return !isCommandBoundary(value) || hasCommandBoundary(argv, nextIndex);
+}
+
+function hasCommandBoundary(argv, startIndex) {
+  let index = startIndex;
+  while (RUNTIME_FLAGS.has(argv[index])) {
+    if (!isPlainValue(argv[index + 1])) return false;
+    index += 2;
+  }
+  return isCommandBoundary(argv[index]);
+}
+
+function isPlainValue(value) {
+  return typeof value === 'string' && Boolean(value.trim()) &&
+    !value.startsWith('--') && value !== '-h';
+}
+
+function isCommandBoundary(value) {
+  return isCliCommand(value);
+}

package/src/cli/local-runtime-command.js

@@ -0,0 +1,94 @@
+import {
+  inspectLocalRuntime,
+  openLocalConsole,
+  restartLocalRuntime,
+  startLocalRuntime,
+  stopLocalRuntime
+} from '../local-runtime/lifecycle.js';
+import { resolveSetupPaths } from '../setup/paths.js';
+import { parseLocalRuntimeOptions } from './local-runtime-options.js';
+
+export async function runLocalRuntimeCommand(command, args, dependencies = {}) {
+  const options = parseLocalRuntimeOptions(command, args);
+  const resolvePaths = dependencies.resolvePaths ?? resolveSetupPaths;
+  const env = dependencies.env ?? process.env;
+  const paths = resolvePaths({ dataDir: options.dataDir, env });
+  const write = dependencies.write ?? writeLine;
+  const input = { ...options, paths, env, onProgress: write };
+  const handlers = {
+    start: dependencies.start ?? startLocalRuntime,
+    stop: dependencies.stop ?? stopLocalRuntime,
+    restart: dependencies.restart ?? restartLocalRuntime,
+    status: dependencies.inspect ?? inspectLocalRuntime,
+    open: dependencies.openConsole ?? openLocalConsole
+  };
+  const result = await handlers[command](input, dependencies.lifecycleDependencies);
+
+  if (command === 'status' && options.json) {
+    write(JSON.stringify(result, null, 2));
+  } else {
+    write(formatLocalRuntimeResult(command, result));
+  }
+  return {
+    ...result,
+    exitCode: command === 'status' && result.status !== 'running'
+      ? 1
+      : result.status === 'partial' ? 1 : 0
+  };
+}
+
+export function formatLocalRuntimeResult(command, result) {
+  if (command === 'start') {
+    const verb = result.status === 'running' ? '已经在运行' : '已启动';
+    return [`Fuli 本地服务${verb}。`, `管理界面：${result.url}`].join('\n');
+  }
+  if (command === 'restart') {
+    return [`Fuli 本地服务已重启。`, `管理界面：${result.url}`].join('\n');
+  }
+  if (command === 'stop') {
+    if (result.status === 'partial') {
+      return [
+        'Fuli 本地 Provider 已停止，但没有终止无法验证身份的界面进程。',
+        '请执行 fl status 检查，避免误停其他进程。'
+      ].join('\n');
+    }
+    return result.console === 'not_running' && result.providers === 'not_initialized'
+      ? 'Fuli 本地服务尚未初始化。'
+      : 'Fuli 本地服务已停止，图谱数据已保留。';
+  }
+  if (command === 'open') return `已打开：${result.url}`;
+  if (command === 'status') return formatStatus(result);
+  throw new TypeError(`Unknown local runtime command: ${command}`);
+}
+
+function formatStatus(result) {
+  const labels = {
+    running: '运行中',
+    degraded: '部分可用',
+    stopped: '已停止',
+    not_configured: '未初始化',
+    ready: '可用',
+    unavailable: '不可用',
+    not_connected: '未连接',
+    not_configured_provider: '未配置',
+    unverified: '身份未验证'
+  };
+  const publicSummary = result.public.configured
+    ? `${labels[result.public.status] ?? result.public.status}（${result.public.providers.length} 个 Provider）`
+    : labels.not_connected;
+  return [
+    `Fuli 本地状态：${labels[result.status] ?? result.status}`,
+    `管理界面：${labels[result.console.status] ?? result.console.status} · ${result.console.url}`,
+    `个人图谱：${providerLabel(result.personal.status, labels)}`,
+    `公共服务：${publicSummary}`
+  ].join('\n');
+}
+
+function providerLabel(status, labels) {
+  if (status === 'not_configured') return labels.not_configured_provider;
+  return labels[status] ?? status;
+}
+
+function writeLine(value) {
+  process.stdout.write(`${value}\n`);
+}