@floegence/floe-webapp-core 0.35.7 → 0.35.8

package/dist/terminal/editorModel.d.ts

@@ -0,0 +1,7 @@
+import type { TerminalEditorState } from './types';
+export declare function createTerminalEditorState(value?: string): TerminalEditorState;
+export declare function insertTerminalText(state: TerminalEditorState, text: string): TerminalEditorState;
+export declare function deleteTerminalTextBackward(state: TerminalEditorState): TerminalEditorState;
+export declare function moveTerminalCursor(state: TerminalEditorState, direction: 'left' | 'right'): TerminalEditorState;
+export declare function navigateTerminalHistory(state: TerminalEditorState, history: readonly string[], direction: 'up' | 'down'): TerminalEditorState;
+export declare function clampTerminalCursor(cursor: number, valueLength: number): number;

package/dist/terminal/editorModel.js

@@ -0,0 +1,84 @@
+function h(r = "") {
+  return {
+    value: r,
+    cursor: r.length,
+    historyIndex: null,
+    draft: ""
+  };
+}
+function d(r, n) {
+  if (!n) return r;
+  const u = o(r.cursor, r.value.length);
+  return {
+    value: r.value.slice(0, u) + n + r.value.slice(u),
+    cursor: u + n.length,
+    historyIndex: null,
+    draft: ""
+  };
+}
+function f(r) {
+  const n = o(r.cursor, r.value.length);
+  return n === 0 ? r : {
+    value: r.value.slice(0, n - 1) + r.value.slice(n),
+    cursor: n - 1,
+    historyIndex: null,
+    draft: ""
+  };
+}
+function a(r, n) {
+  const u = o(r.cursor, r.value.length), e = n === "left" ? Math.max(0, u - 1) : Math.min(r.value.length, u + 1);
+  return e === u ? r : {
+    ...r,
+    cursor: e
+  };
+}
+function x(r, n, u) {
+  if (!n.length) return r;
+  if (u === "up") {
+    if (r.historyIndex === null) {
+      const t = n[n.length - 1] ?? "";
+      return {
+        value: t,
+        cursor: t.length,
+        historyIndex: n.length - 1,
+        draft: r.value
+      };
+    }
+    const l = Math.max(0, r.historyIndex - 1);
+    if (l === r.historyIndex) return r;
+    const i = n[l] ?? "";
+    return {
+      ...r,
+      value: i,
+      cursor: i.length,
+      historyIndex: l
+    };
+  }
+  if (r.historyIndex === null) return r;
+  const e = r.historyIndex + 1;
+  if (e >= n.length)
+    return {
+      value: r.draft,
+      cursor: r.draft.length,
+      historyIndex: null,
+      draft: ""
+    };
+  const c = n[e] ?? "";
+  return {
+    ...r,
+    value: c,
+    cursor: c.length,
+    historyIndex: e
+  };
+}
+function o(r, n) {
+  return Math.max(0, Math.min(n, r));
+}
+export {
+  o as clampTerminalCursor,
+  h as createTerminalEditorState,
+  f as deleteTerminalTextBackward,
+  d as insertTerminalText,
+  a as moveTerminalCursor,
+  x as navigateTerminalHistory
+};

package/dist/terminal/mockRuntime.d.ts

@@ -0,0 +1,2 @@
+import type { TerminalRuntimeAdapter } from './types';
+export declare const runTerminalMockCommand: TerminalRuntimeAdapter;

package/dist/terminal/mockRuntime.js

@@ -0,0 +1,287 @@
+import { normalizeTerminalWorkspaceProfile as T } from "./workspaceProfile.js";
+const y = {
+  "README.md": `# Floe Webapp
+Terminal-first demo workspace with a mobile keyboard.`,
+  "package.json": `{
+  "name": "floe-webapp",
+  "scripts": {
+    "dev": "node scripts/dev.mjs",
+    "build": "pnpm -r build"
+  }
+}`,
+  "pnpm-lock.yaml": `lockfileVersion: "9.0"
+packages:
+  packages/core:
+    version: 0.35.7
+  packages/protocol:
+    version: 0.35.7`,
+  "tsconfig.json": `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext"
+  }
+}`,
+  ".env.local": `VITE_FLOE_CONTROLPLANE_BASE_URL=https://controlplane.example.com
+VITE_FLOE_ENDPOINT_ID=demo-endpoint`,
+  "scripts/dev.mjs": `import { spawn } from 'node:child_process';
+
+spawn('pnpm', ['--filter', '@floegence/floe-webapp-demo', 'dev'], { stdio: 'inherit' });`
+}, B = (s, r) => {
+  const n = T(r?.profile), u = r?.resolveNow ?? (() => (/* @__PURE__ */ new Date()).toString()), e = s.trim();
+  if (!e)
+    return {
+      clear: !1,
+      lines: []
+    };
+  if (e === "help")
+    return t(
+      [
+        "Available commands:",
+        'pwd, ls, ls -la, cat <file>, less <file>, head -n <count> <file>, tail -n <count> <file>, wc -l|-w|-c <file>, mkdir -p <dir>, touch <file>, chmod <mode> <target>, clear, date, echo <text>, echo "$PATH", echo "$SHELL"',
+        "git status, git diff, git log --oneline -10, git add ., git checkout -b <branch>, git commit -m <message>",
+        `pnpm ${n.scripts.join(", pnpm ")}`,
+        "find . -name <pattern>, grep -R <pattern> src/, grep -n <pattern> <file>, grep -i <pattern> <file>, sort <file>, cut <options> <file>, uname -a, vim <file>, sed -n <range> <file>, awk <program> <file>",
+        "curl -I|-L <url>, tar -czf|-xzf|-tf <archive>, ssh <host>, scp <src> <dest>"
+      ].join(`
+`)
+    );
+  if (e === "pwd")
+    return t(n.cwd);
+  if (e === "ls" || e === "ls -la") {
+    const i = [...n.directories, ...n.files];
+    return t(
+      e === "ls" ? i.join("  ") : [
+        ...n.directories.map((o) => `drwxr-xr-x  ${o}`),
+        ...n.files.map((o) => `-rw-r--r--  ${o}`)
+      ].join(`
+`)
+    );
+  }
+  if (e.startsWith("ls ")) {
+    const i = e.slice(3).trim().replace(/\/$/, "");
+    if (n.directories.includes(i))
+      return t(i === "packages" ? "boot  core  init  protocol" : i === "apps" ? "demo" : i === "src" ? "app.ts  widgets  terminal  components" : `${i}/`);
+  }
+  if (e === "clear")
+    return {
+      clear: !0,
+      lines: []
+    };
+  if (e === "date")
+    return t(u());
+  if (e === 'echo "$PATH"')
+    return t("/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin");
+  if (e === 'echo "$SHELL"')
+    return t("/bin/zsh");
+  if (e.startsWith("echo "))
+    return t(e.slice(5));
+  if (e === "uname -a")
+    return t("Darwin floe-webapp.local 24.4.0 Darwin Kernel Version 24.4.0 arm64");
+  if (e === "uname -sr")
+    return t("Darwin 24.4.0");
+  if (e === "uname -m")
+    return t("arm64");
+  if (e === "git status")
+    return t(`On branch main
+nothing to commit, working tree clean`);
+  if (e === "git diff")
+    return t(`diff --git a/packages/core/src/terminal/suggestionEngine.ts b/packages/core/src/terminal/suggestionEngine.ts
+index 1234567..89abcde 100644`);
+  if (e === "git log --oneline -10" || e === "git log --oneline")
+    return t(`307a37e merge mobile keyboard
+c942cb5 add terminal-first mobile keyboard
+37fa316 release 0.35.7`);
+  if (e === "git add .")
+    return t("staged tracked changes");
+  const f = e.match(/^git checkout -b\s+(.+)$/);
+  if (f)
+    return t(`Switched to a new branch '${f[1]}'`);
+  const m = e.match(/^git commit -m\s+"(.+)"$/);
+  if (m)
+    return t(`[main abc1234] ${m[1]}
+ 3 files changed, 42 insertions(+), 8 deletions(-)`);
+  const d = e.match(/^cat\s+(.+)$/);
+  if (d) {
+    const i = p(n.files, d[1] ?? "");
+    if (i)
+      return t(i);
+  }
+  const j = e.match(/^vim\s+(.+)$/);
+  if (j) {
+    const i = l(j[1] ?? ""), o = p(n.files, i);
+    if (o)
+      return t(S(i, o));
+  }
+  const $ = e.match(/^pnpm\s+([a-z0-9:-]+)$/i);
+  if ($ && n.scripts.includes($[1] ?? ""))
+    return t(`> pnpm ${$[1]}
+completed mock run for script '${$[1]}'`);
+  if (e.match(/^find \. -name\s+(.+)$/))
+    return t(["./README.md", "./packages/core/src/terminal/suggestionEngine.ts"].join(`
+`));
+  if (e.match(/^grep -R\s+(.+)\s+src\/?$/))
+    return t("src/terminal/suggestionEngine.ts:getTerminalSuggestions");
+  const b = e.match(/^grep\s+(-n|-i)\s+(.+?)\s+(.+)$/);
+  if (b) {
+    const i = b[1] ?? "", o = C(b[2] ?? ""), c = l(b[3] ?? ""), a = p(n.files, c);
+    if (a)
+      return t(W(a, c, o, i));
+  }
+  const v = e.match(/^less\s+(.+)$/);
+  if (v) {
+    const i = l(v[1] ?? ""), o = p(n.files, i);
+    if (o)
+      return t(`${o}
+(END)`);
+  }
+  const L = e.match(/^mkdir\s+-p\s+(.+)$/);
+  if (L)
+    return t(`created directory ${l(L[1] ?? "")}`);
+  const N = e.match(/^touch\s+(.+)$/);
+  if (N)
+    return t(`updated timestamp for ${l(N[1] ?? "")}`);
+  const M = e.match(/^chmod\s+(.+?)\s+(.+)$/);
+  if (M)
+    return t(
+      `mode ${M[1] ?? ""} applied to ${l(M[2] ?? "")}`
+    );
+  const h = e.match(/^head(?:\s+-n\s+(\d+))?(?:\s+-c\s+(\d+))?\s+(.+)$/);
+  if (h) {
+    const i = Number(h[1] ?? 10), o = h[2] ? Number(h[2]) : null, c = l(h[3] ?? ""), a = p(n.files, c);
+    if (a)
+      return t(
+        o === null ? z(a, i) : a.slice(0, Math.max(0, o))
+      );
+  }
+  const g = e.match(/^tail(?:\s+-n\s+(\d+))?(?:\s+-c\s+(\d+))?\s+(.+)$/);
+  if (g) {
+    const i = Number(g[1] ?? 10), o = g[2] ? Number(g[2]) : null, c = l(g[3] ?? ""), a = p(n.files, c);
+    if (a)
+      return t(
+        o === null ? D(a, i) : a.slice(Math.max(0, a.length - Math.max(0, o)))
+      );
+  }
+  const w = e.match(/^wc\s+(-[lwc])\s+(.+)$/);
+  if (w) {
+    const i = w[1] ?? "", o = l(w[2] ?? ""), c = p(n.files, o);
+    if (c)
+      return t(A(c, o, i));
+  }
+  const x = e.match(/^sort(?:\s+(-u|-r))?\s+(.+)$/);
+  if (x) {
+    const i = x[1] ?? "", o = l(x[2] ?? ""), c = p(n.files, o);
+    if (c)
+      return t(F(c, i));
+  }
+  const E = e.match(/^cut\s+(.+)\s+(.+)$/);
+  if (E) {
+    const i = E[1] ?? "", o = l(E[2] ?? ""), c = p(n.files, o);
+    if (c)
+      return t(_(c, i));
+  }
+  const k = e.match(/^sed -n '(\d+),(\d+)p'\s+(.+)$/);
+  if (k) {
+    const i = Number(k[1] ?? 1), o = Number(k[2] ?? i), c = l(k[3] ?? ""), a = p(n.files, c);
+    if (a)
+      return t(R(a, i, o));
+  }
+  return e === "sed -E 's/floe/Floe/g' README.md" ? t(`# Floe Webapp
+Terminal-first demo workspace with a mobile keyboard.`) : e === "awk '{print $1}' package.json" ? t(["{", '"name":', '"scripts":', '"dev":', '"build":', "}", "}"].join(`
+`)) : e === "awk 'NR<=20 {print}' README.md" ? t(`# Floe Webapp
+Terminal-first demo workspace with a mobile keyboard.`) : e === `awk '/scripts/ {print NR ":" $0}' package.json` ? t('3:  "scripts": {') : e === "curl -I https://example.com" ? t(
+    [
+      "HTTP/2 200",
+      "content-type: text/html; charset=utf-8",
+      "cache-control: max-age=300"
+    ].join(`
+`)
+  ) : e === "curl -L https://example.com" ? t(`<!doctype html>
+<html>
+  <body>Example Domain</body>
+</html>`) : e === 'curl -H "Authorization: Bearer " https://api.example.com' ? t('{"error":"missing bearer token"}') : e === "tar -czf floe-webapp.tgz packages/" ? t("created archive floe-webapp.tgz from packages/") : e === "tar -xzf floe-webapp.tgz" ? t("extracted archive floe-webapp.tgz") : e === "tar -tf floe-webapp.tgz" ? t(["packages/", "packages/core/", "packages/protocol/"].join(`
+`)) : e === "ssh user@example.com" ? t(`Connected to user@example.com
+Last login: Tue Mar 17 22:00:00 2026`) : e === "ssh -p 22 user@example.com" ? t("Connected to user@example.com on port 22") : e === "scp README.md user@example.com:/tmp/" ? t("README.md                                    100%   58B   1.2KB/s   00:00") : e === "scp -r scripts/ user@example.com:/tmp/scripts/" ? t("scripts/                                     100% copied recursively") : {
+    clear: !1,
+    lines: [
+      {
+        type: "error",
+        content: `Command not found: ${e}`
+      }
+    ]
+  };
+};
+function t(s) {
+  return {
+    clear: !1,
+    lines: [
+      {
+        type: "output",
+        content: s
+      }
+    ]
+  };
+}
+function p(s, r) {
+  const n = l(r);
+  return !n || !s.includes(n) ? null : y[n] ?? `// Mock contents for ${n}
+// Generated by the shared terminal runtime.`;
+}
+function l(s) {
+  return s.trim().replace(/\/$/, "");
+}
+function C(s) {
+  const r = s.trim();
+  return r.startsWith('"') && r.endsWith('"') || r.startsWith("'") && r.endsWith("'") ? r.slice(1, -1) : r;
+}
+function z(s, r) {
+  return s.split(`
+`).slice(0, Math.max(0, r)).join(`
+`);
+}
+function D(s, r) {
+  return s.split(`
+`).slice(-Math.max(0, r)).join(`
+`);
+}
+function R(s, r, n) {
+  return s.split(`
+`).slice(Math.max(0, r - 1), Math.max(r - 1, n)).join(`
+`);
+}
+function S(s, r) {
+  return `"${s}" ${r.split(`
+`).length}L, ${r.length}B
+~
+Mock vim session opened for ${s}`;
+}
+function A(s, r, n) {
+  return n === "-l" ? `${s.split(`
+`).length} ${r}` : n === "-w" ? `${s.trim().split(/\s+/).filter(Boolean).length} ${r}` : `${s.length} ${r}`;
+}
+function W(s, r, n, u) {
+  if (!n)
+    return `${r}: pattern is empty`;
+  const e = u === "-i" ? n.toLowerCase() : n;
+  return s.split(`
+`).map((m, d) => ({ line: m, index: d })).filter(
+    ({ line: m }) => (u === "-i" ? m.toLowerCase() : m).includes(e)
+  ).map(({ line: m, index: d }) => u === "-n" ? `${d + 1}:${m}` : m).join(`
+`) || `${r}: no matches`;
+}
+function F(s, r) {
+  const u = [...s.split(`
+`)].sort((e, f) => e.localeCompare(f));
+  return r === "-u" ? [...new Set(u)].join(`
+`) : r === "-r" ? u.reverse().join(`
+`) : u.join(`
+`);
+}
+function _(s, r) {
+  const n = r.match(/-d\s+"([^"]+)"/), u = r.match(/-f\s+(\d+)/), e = n?.[1] ?? "	", f = Math.max(1, Number(u?.[1] ?? 1)) - 1;
+  return s.split(`
+`).map((m) => m.split(e)[f] ?? "").join(`
+`);
+}
+export {
+  B as runTerminalMockCommand
+};

package/dist/terminal/sessionModel.d.ts

@@ -0,0 +1,37 @@
+import { type TerminalSuggestionEngineOptions } from './suggestionEngine';
+import type { TerminalEditorState, TerminalSuggestion, TerminalWorkspaceProfile } from './types';
+export interface TerminalSessionState {
+    editor: TerminalEditorState;
+    history: string[];
+}
+export interface TerminalPromptPreview {
+    before: string;
+    cursor: string;
+    after: string;
+}
+export type TerminalSessionEffect = {
+    type: 'none';
+} | {
+    type: 'submit';
+    command: string;
+} | {
+    type: 'interrupt';
+    command: string | null;
+} | {
+    type: 'clear-screen';
+};
+export interface TerminalSessionTransition {
+    state: TerminalSessionState;
+    effect: TerminalSessionEffect;
+}
+export interface TerminalSessionSuggestionOptions extends TerminalSuggestionEngineOptions {
+    profile?: Partial<TerminalWorkspaceProfile>;
+    maxItems?: number;
+}
+export declare function createTerminalSessionState(value?: string): TerminalSessionState;
+export declare function setTerminalSessionInputValue(state: TerminalSessionState, value: string): TerminalSessionState;
+export declare function getTerminalPromptPreview(editor: TerminalEditorState): TerminalPromptPreview;
+export declare function getTerminalSessionSuggestions(state: TerminalSessionState, options?: TerminalSessionSuggestionOptions): TerminalSuggestion[];
+export declare function applyTerminalSessionSuggestion(state: TerminalSessionState, suggestion: TerminalSuggestion): TerminalSessionState;
+export declare function submitTerminalSession(state: TerminalSessionState): TerminalSessionTransition;
+export declare function dispatchTerminalSessionKey(state: TerminalSessionState, key: string, options?: Omit<TerminalSessionSuggestionOptions, 'maxItems'>): TerminalSessionTransition;

package/dist/terminal/sessionModel.js

@@ -0,0 +1,143 @@
+import { createTerminalEditorState as o, deleteTerminalTextBackward as l, navigateTerminalHistory as t, moveTerminalCursor as u, insertTerminalText as m } from "./editorModel.js";
+import { applyTerminalSuggestion as c, autocompleteTerminalInput as d, getTerminalSuggestions as s } from "./suggestionEngine.js";
+function h(r = "") {
+  return {
+    editor: o(r),
+    history: []
+  };
+}
+function g(r, e) {
+  return {
+    ...r,
+    editor: o(e)
+  };
+}
+function v(r) {
+  const e = r.value, i = Math.max(0, Math.min(r.cursor, e.length));
+  return {
+    before: e.slice(0, i),
+    cursor: i < e.length ? e[i] ?? " " : " ",
+    after: i < e.length ? e.slice(i + 1) : ""
+  };
+}
+function S(r, e) {
+  return s(
+    {
+      value: r.editor.value,
+      cursor: r.editor.cursor,
+      history: r.history,
+      profile: e?.profile,
+      maxItems: e?.maxItems
+    },
+    {
+      providers: e?.providers
+    }
+  );
+}
+function x(r, e) {
+  return {
+    ...r,
+    editor: c(r.editor, e)
+  };
+}
+function p(r) {
+  const e = r.editor.value;
+  return e.trim() ? {
+    state: {
+      editor: o(),
+      history: [...r.history, e]
+    },
+    effect: {
+      type: "submit",
+      command: e
+    }
+  } : {
+    state: r,
+    effect: { type: "none" }
+  };
+}
+function y(r, e, i) {
+  if (!e)
+    return {
+      state: r,
+      effect: { type: "none" }
+    };
+  if (e === "\r")
+    return p(r);
+  if (e === "")
+    return n(r, l(r.editor));
+  if (e === "	")
+    return n(
+      r,
+      d(
+        r.editor,
+        {
+          history: r.history,
+          profile: i?.profile
+        },
+        {
+          providers: i?.providers
+        }
+      )
+    );
+  if (e === "\x1B[A")
+    return n(
+      r,
+      t(r.editor, r.history, "up")
+    );
+  if (e === "\x1B[B")
+    return n(
+      r,
+      t(r.editor, r.history, "down")
+    );
+  if (e === "\x1B[D")
+    return n(r, u(r.editor, "left"));
+  if (e === "\x1B[C")
+    return n(r, u(r.editor, "right"));
+  if (e === "") {
+    const f = r.editor.value || null;
+    return {
+      state: {
+        ...r,
+        editor: o()
+      },
+      effect: {
+        type: "interrupt",
+        command: f
+      }
+    };
+  }
+  return e === "\f" ? {
+    state: {
+      ...r,
+      editor: o()
+    },
+    effect: {
+      type: "clear-screen"
+    }
+  } : e.startsWith("\x1B") ? {
+    state: r,
+    effect: { type: "none" }
+  } : n(r, m(r.editor, e));
+}
+function n(r, e) {
+  return e === r.editor ? {
+    state: r,
+    effect: { type: "none" }
+  } : {
+    state: {
+      ...r,
+      editor: e
+    },
+    effect: { type: "none" }
+  };
+}
+export {
+  x as applyTerminalSessionSuggestion,
+  h as createTerminalSessionState,
+  y as dispatchTerminalSessionKey,
+  v as getTerminalPromptPreview,
+  S as getTerminalSessionSuggestions,
+  g as setTerminalSessionInputValue,
+  p as submitTerminalSession
+};

package/dist/terminal/suggestionEngine.d.ts

@@ -0,0 +1,64 @@
+import type { TerminalEditorState, TerminalSuggestion, TerminalSuggestionKind, TerminalSuggestionRequest, TerminalWorkspaceProfile } from './types';
+export interface TerminalToken {
+    text: string;
+    from: number;
+    to: number;
+}
+export interface ParsedTerminalSuggestionContext {
+    value: string;
+    cursor: number;
+    tokens: TerminalToken[];
+    command: string | null;
+    activeTokenIndex: number;
+    activeTokenPrefix: string;
+    activeTokenText: string;
+    activeReplaceFrom: number;
+    activeReplaceTo: number;
+    atTokenBoundary: boolean;
+}
+export interface TerminalSuggestionProviderInput {
+    request: TerminalSuggestionRequest;
+    profile: TerminalWorkspaceProfile;
+    context: ParsedTerminalSuggestionContext;
+}
+export type TerminalSuggestionProvider = (input: TerminalSuggestionProviderInput) => readonly TerminalSuggestion[];
+export interface TerminalSuggestionEngineOptions {
+    providers?: readonly TerminalSuggestionProvider[];
+}
+export interface TerminalFullLineSuggestionSpec {
+    id: string;
+    kind: TerminalSuggestionKind;
+    label: string;
+    detail?: string;
+    score: number;
+    insertText?: string;
+    replaceTo?: number;
+    nextCursorOffset?: number;
+}
+export interface TerminalTokenSuggestionSpec {
+    id: string;
+    kind: TerminalSuggestionKind;
+    label: string;
+    insertText: string;
+    detail?: string;
+    score: number;
+    replaceFrom?: number;
+    replaceTo?: number;
+    nextCursorOffset?: number;
+}
+export declare const terminalHistorySuggestionProvider: TerminalSuggestionProvider;
+export declare const terminalRootSuggestionProvider: TerminalSuggestionProvider;
+export declare const terminalCommandTokenSuggestionProvider: TerminalSuggestionProvider;
+export declare const terminalPathSuggestionProvider: TerminalSuggestionProvider;
+export declare const terminalSnippetSuggestionProvider: TerminalSuggestionProvider;
+export declare const DEFAULT_TERMINAL_SUGGESTION_PROVIDERS: readonly TerminalSuggestionProvider[];
+export declare function getTerminalSuggestions(request: TerminalSuggestionRequest, options?: TerminalSuggestionEngineOptions): TerminalSuggestion[];
+export declare function autocompleteTerminalInput(state: TerminalEditorState, requestOptions?: Omit<TerminalSuggestionRequest, 'value' | 'cursor'>, options?: TerminalSuggestionEngineOptions): TerminalEditorState;
+export declare function applyTerminalSuggestion(state: TerminalEditorState, suggestion: TerminalSuggestion): TerminalEditorState;
+export declare function createTerminalFullLineSuggestion(context: ParsedTerminalSuggestionContext, input: TerminalFullLineSuggestionSpec): TerminalSuggestion;
+export declare function createTerminalTokenSuggestion(context: ParsedTerminalSuggestionContext, input: TerminalTokenSuggestionSpec): TerminalSuggestion;
+export declare function matchesTerminalSuggestionPrefix(context: ParsedTerminalSuggestionContext, input: {
+    label: string;
+    matchText?: string;
+}): boolean;
+export declare function parseTerminalSuggestionContext(value: string, cursor?: number): ParsedTerminalSuggestionContext;