dsh-plugin-git-commit-push 0.0.0-stage → 1.0.1

package/lib/schema.js

@@ -0,0 +1,111 @@
+/**
+ * The Cordis `Config` schema, i.e. the plugin's visual settings form.
+ *
+ * HOW DSH TURNS THIS INTO A FORM
+ * A plugin whose row accepts a `config` mapping exports a schemastery schema as
+ * `Config`. DSH's `@deepseek-ai/dsh-settings` service derives a namespace from
+ * it (`autoGenerate`), the Settings page renders the fields, and
+ * `@deepseek-ai/dsh-config-editor` writes what the person chose into the active
+ * profile's `cordis.patch.yml` — for our own entry id, so it lands next to the
+ * loader row this bundle inserts, in the same place `ui-theme`'s `preference`
+ * lives. A field declared `.volatile()` is written into the running references
+ * and announced with `loader/volatile-update`, which is why our values are read
+ * through `.get()` on every call instead of being cached at mount: a change in
+ * the form takes effect on the next tool call, with no remount and no restart.
+ *
+ * WHY LOADING THE LIBRARY IS GUARDED
+ * The plugin deliberately keeps its runtime imports to itself: with a `link:`
+ * install the schema library is reachable only because the launcher installs a
+ * runtime resolution computed from the installation and the bundle dependency
+ * graphs. If that ever fails, the right outcome is a plugin without a settings
+ * form — not a plugin that cannot mount. So the library is loaded through
+ * `createRequire` inside a `try`, and every failure (missing library, a schema
+ * the library rejects, an unexpected builder result) degrades to `Config ===
+ * undefined`, which DSH reads as "this row has no configuration fields".
+ *
+ * VOLATILE PLACEMENT RULES (enforced by schemastery, easy to get wrong)
+ * `validateVolatileSchema` throws for a volatile field under a dict value, an
+ * array item, a map key, or a union/lazy branch: volatile fields must sit at a
+ * fixed object path and must not be nested inside another volatile field. Every
+ * field below is therefore a direct leaf of the root object (or a leaf of the
+ * fixed-path `pinnedIdentity` object), never a union or an array item.
+ */
+import { createRequire } from 'node:module'
+
+import { FIELDS, IDENTITY_FIELDS, loadFileSettingsSync } from './config.js'
+
+/**
+ * Load `@deepseek-ai/schemastery` without letting a resolution failure matter.
+ *
+ * @returns {any | undefined} the schema constructor, or undefined
+ */
+export function loadSchemaLibrary() {
+  try {
+    const require = createRequire(import.meta.url)
+    const loaded = require('@deepseek-ai/schemastery')
+    const Schema = loaded?.default ?? loaded
+    return typeof Schema === 'function' ? Schema : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** One leaf field: typed, defaulted from the settings file, described, volatile. */
+function leaf(Schema, field, value) {
+  const base = field.kind === 'boolean'
+    ? Schema.boolean()
+    : field.kind === 'number'
+      ? Schema.number()
+      : Schema.string()
+  let node = base.default(value).description(field.label)
+  if (typeof field.min === 'number') node = node.min(field.min)
+  return node.volatile()
+}
+
+/** Why the schema could not be built, for the log and for tests. */
+let schemaProblem
+
+/** The reason `CONFIG` is undefined, or undefined when it was built. */
+export function schemaBuildProblem() {
+  return schemaProblem
+}
+
+/**
+ * Build the schema.
+ *
+ * Defaults come from the settings file so the form opens on the values the
+ * plugin is actually using; the built-in defaults remain the last resort.
+ *
+ * @param {any} Schema the schemastery constructor (or undefined)
+ * @param {typeof import('./config.js').DEFAULTS} [seed] values to use as defaults
+ * @returns {any | undefined} the schema, or undefined when it cannot be built
+ */
+export function buildConfigSchema(Schema, seed = loadFileSettingsSync()) {
+  if (Schema === undefined) {
+    schemaProblem = '@deepseek-ai/schemastery could not be resolved from this package'
+    return undefined
+  }
+  try {
+    const fields = {}
+    for (const field of FIELDS) fields[field.key] = leaf(Schema, field, seed[field.key])
+    fields.pinnedIdentity = Schema.object({
+      [IDENTITY_FIELDS[0].key]: leaf(Schema, IDENTITY_FIELDS[0], seed.pinnedIdentity?.name ?? ''),
+      [IDENTITY_FIELDS[1].key]: leaf(Schema, IDENTITY_FIELDS[1], seed.pinnedIdentity?.email ?? ''),
+    }).description('仅本次提交使用的 git 身份（以 -c 传入，不会改写你的 git 配置）')
+    const schema = Schema.object(fields)
+    schemaProblem = undefined
+    return schema
+  } catch (error) {
+    // A schema the library rejects would otherwise take the whole plugin down at
+    // mount; a missing settings form is the lesser failure by far.
+    schemaProblem = `${error?.name ?? 'Error'}: ${error?.message ?? String(error)}`
+    return undefined
+  }
+}
+
+/**
+ * The schema DSH mounts with this plugin.
+ *
+ * `undefined` when the schema library cannot be reached — see the note above.
+ */
+export const CONFIG = buildConfigSchema(loadSchemaLibrary())

package/lib/skill.js

@@ -0,0 +1,95 @@
+/**
+ * The `git-commit-push` skill this plugin registers at mount time.
+ *
+ * WHY THE PLUGIN SHIPS ITS OWN SKILL
+ * The trigger policy — "commit only when the user asked, never on your own
+ * initiative" — has to reach the model through every surface it consults, not
+ * just the tool description. A skill file gives the model the full procedure
+ * (two-step `prepare` → `apply`, message conventions, boundaries) on demand.
+ *
+ * Why register it at runtime instead of telling the user to copy SKILL.md into
+ * their skills directory: this package is published to npm, so it is installed
+ * into `node_modules`, and asking every user to copy a file out of there by
+ * hand is exactly the kind of setup step that npm publishing is supposed to
+ * remove. `ctx.skills.register(...)` is the documented seam for an in-memory
+ * ("embedded") skill and needs no filesystem root.
+ *
+ * Source of truth is the shipped SKILL.md: the name, the description and the
+ * body are parsed from it, so the npm page, the skill catalog and the file can
+ * never drift. Precedence is the registry's business: a PROJECT-level skill of
+ * the same name outranks this runtime registration, so a user who keeps their
+ * own `git-commit-push` skill in the workspace still wins.
+ */
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+
+const here = dirname(fileURLToPath(import.meta.url))
+
+/** Absolute path of the shipped skill file. */
+export const SKILL_PATH = join(here, '..', 'SKILL.md')
+
+/** Kebab-case skill name, as the registry's grammar demands. Matches the package name. */
+export const SKILL_NAME = 'git-commit-push'
+
+/** `source` label shown in skill listings; the registry adds the `runtime` provider. */
+export const SKILL_SOURCE = 'dsh-plugin-git-commit-push'
+
+/** The registry's public skill-name grammar (see `@deepseek-ai/dsh-skill`). */
+const SKILL_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+
+/**
+ * Split a `---`-fenced frontmatter block off a skill file.
+ *
+ * Deliberately a reader for the flat `key: value` frontmatter this project
+ * writes, not a YAML parser: the package ships with no dependencies, and the
+ * two fields read here (name, description) are single-line scalars.
+ *
+ * @param {string} text
+ * @returns {{ fields: Record<string, string>, content: string }}
+ */
+export function parseSkillFile(text) {
+  const fenced = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*\r?\n?/.exec(text)
+  if (fenced === null) return { fields: {}, content: text.trim() }
+  const fields = {}
+  for (const line of fenced[1].split(/\r?\n/)) {
+    const pair = /^([A-Za-z][A-Za-z0-9_-]*):[ \t]*(.*)$/.exec(line)
+    if (pair === null) continue
+    const value = pair[2].trim()
+    fields[pair[1]] = /^(['"]).*\1$/.test(value) ? value.slice(1, -1) : value
+  }
+  return { fields, content: text.slice(fenced[0].length).trim() }
+}
+
+/**
+ * The definition handed to `ctx.skills.register(...)`.
+ *
+ * Field requirements are the registry's: a kebab-case `name`, a non-empty
+ * `description`, an optional `{ modelInvocable, userInvocable }` policy, and a
+ * `content` string. `provider` is filled in by the registry (`runtime`), so it
+ * is deliberately absent here.
+ *
+ * @returns {{ name: string, description: string, invocation: { modelInvocable: boolean, userInvocable: boolean }, source: string, content: string } | undefined}
+ *   `undefined` when the shipped file is missing or unusable — a skill that
+ *   cannot be registered must not take the tool down with it.
+ */
+export function skillDefinition() {
+  let parsed
+  try {
+    parsed = parseSkillFile(readFileSync(SKILL_PATH, 'utf8'))
+  } catch {
+    return undefined
+  }
+  const name = parsed.fields.name ?? SKILL_NAME
+  const description = parsed.fields.description ?? ''
+  if (!SKILL_NAME_PATTERN.test(name) || description.trim() === '' || parsed.content.trim() === '') return undefined
+  return {
+    name,
+    description,
+    // The skill is model-facing procedure; the human-facing surface is the
+    // `/git-commit-push` command, so this skill is not offered as a user command.
+    invocation: { modelInvocable: true, userInvocable: false },
+    source: SKILL_SOURCE,
+    content: parsed.content,
+  }
+}

package/lib/survey.js

@@ -0,0 +1,225 @@
+/**
+ * One repository survey: everything the plugin needs to describe a changeset,
+ * gathered with a fixed, small number of git calls.
+ *
+ * Nothing in here writes to the repository. The only content it reads are
+ * bounded diff samples, which is what keeps a survey cheap enough that a model
+ * can afford to call it before every commit.
+ */
+import {
+  currentBranch, git, gitAvailable, hasUpstream, headShort, isRepo,
+  numstat, rawDiff, recentSubjects, repoRoot, resolveRepo, status,
+} from './git.js'
+import {
+  VERSION_FILE, buildMessage, declaredSymbols, removedDeclarationCount, scopeOf, typeOfPath,
+} from './analyze.js'
+
+/** Git porcelain XY codes collapsed to one display status letter. */
+function statusLetter(xy) {
+  const index = xy[0]
+  const worktree = xy[1]
+  if (xy === '??') return '?'
+  if (xy === '!!') return '!'
+  // `--porcelain=v2` uses '.' for "unchanged"; never let it fall through to 'M'.
+  if (index === 'R') return 'R'
+  if (index === 'C') return 'C'
+  if (index === 'D' || worktree === 'D') return 'D'
+  if (index === 'A') return 'A'
+  if (index === 'U' || worktree === 'U' || xy === 'AA' || xy === 'DD') return 'U'
+  if (worktree === 'M' || index === 'M') return 'M'
+  if (index === '.' && worktree === '.') return 'M'
+  return 'M'
+}
+
+/**
+ * Normalize porcelain entries into the plugin's change vocabulary.
+ *
+ * @param {{ xy: string, path: string, origPath?: string }[]} raw
+ * @returns {{ status: string, path: string, staged: boolean, unstaged: boolean, origPath?: string }[]}
+ */
+export function normalizeEntries(raw) {
+  return raw.map(entry => ({
+    status: statusLetter(entry.xy),
+    path: entry.path,
+    staged: entry.xy !== '??' && entry.xy !== '!!' && entry.xy[0] !== ' ' && entry.xy[0] !== '?',
+    unstaged: entry.xy === '??' || entry.xy[1] !== ' ',
+    ...(entry.origPath === undefined ? {} : { origPath: entry.origPath }),
+  }))
+}
+
+/**
+ * Extract a version string from JSON, TOML, YAML or MSBuild text.
+ *
+ * The quote handling is load-bearing: in package.json the line is
+ * `  "version": "1.1.0",`, so a pattern anchored on a bare `version` key never
+ * matches and the tag question would silently never fire for the single most
+ * common version-carrying file.
+ */
+function parseVersion(text) {
+  if (typeof text !== 'string' || text === '') return undefined
+  try {
+    const data = JSON.parse(text)
+    if (typeof data?.version === 'string') return data.version
+    if (typeof data?.Project?.Version === 'string') return data.Project.Version
+  } catch {
+    // Not JSON; fall through to the text patterns.
+  }
+  const patterns = [
+    // "version": "1.1.0"   /   version = '1.1.0'   /   version: 1.1.0
+    /^\s*["']?version["']?\s*[:=]\s*["']?(v?\d[\w.\-+]*)["']?/mi,
+    // MSBuild: <Version>1.1.0</Version>
+    /<Version>\s*([\w.\-+]+)\s*<\/Version>/i,
+    // Python module dunder: __version__ = "1.1.0"
+    /^\s*__version__\s*[:=]\s*["']?(v?\d[\w.\-+]*)["']?/mi,
+  ]
+  for (const pattern of patterns) {
+    const match = pattern.exec(text)
+    if (match !== null) return match[1]
+  }
+  return undefined
+}
+
+/**
+ * Detect a version bump by reading both sides from the repository itself.
+ *
+ * Both sides come from git (`git show HEAD:<f>` and `git show :<f>` — the index),
+ * never from the working tree, so an unstaged edit can never be reported as the
+ * version being committed, and the two sides are read in exactly the form
+ * `git add -A` + commit would use.
+ *
+ * @returns {Promise<{ file: string, from?: string, to?: string } | undefined>}
+ */
+async function detectVersion(root, files) {
+  for (const file of files) {
+    let staged
+    try {
+      staged = await git(root, ['diff', '--cached', '--no-color', '--', file], { timeoutMs: 15_000 })
+    } catch {
+      continue
+    }
+    if (staged.trim() === '') continue
+
+    // Read the staged blob in full rather than rejoining the diff's added lines:
+    // a re-joined fragment is not valid JSON, which is exactly how a package.json
+    // bump used to be missed.
+    const to = parseVersion(await showBlob(root, `:${file}`))
+    if (to === undefined) continue
+    const from = parseVersion(await showBlob(root, `HEAD:${file}`))
+    if (from === to) continue
+    return { file, ...(from === undefined ? {} : { from }), to }
+  }
+  return undefined
+}
+
+/** Best-effort read of one blob; undefined when the revision has no such path. */
+async function showBlob(root, rev) {
+  try {
+    return await git(root, ['show', rev], { timeoutMs: 15_000 })
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Read a repository and describe its pending changes.
+ *
+ * One deliberate side effect: when a version-carrying file is among the
+ * changes, that file is staged before the version is read. A version bump is
+ * only visible in `git diff --cached`, and this is what lets `prepare` report
+ * "1.2.3 → 1.2.4" — and therefore offer the right tag — without a second tool
+ * call. The commit path stages everything anyway, so nothing is decided early.
+ *
+ * @param {object} input
+ * @param {string} input.cwd the session working directory
+ * @param {string} [input.cwdOverride] an explicit repository path from the caller
+ * @param {number} [input.maxFilesShown]
+ * @param {'zh' | 'en'} [input.language]
+ * @returns {Promise<
+ *   | { ok: false, notRepo: true, candidates: string[] }
+ *   | { ok: false, notRepo?: false, reason: string, message: string }
+ *   | { ok: true, root: string, branch: string, entries: any[], stats: Map<string, any>,
+ *       recentSubjects: string[], version?: object, breaking: boolean,
+ *       draft: { message: string, type: string, scope?: string, subject: string },
+ *       hasUpstream: boolean, head?: string, unifiedDiff: string }
+ * >}
+ */
+export async function survey(input) {
+  const { cwd, cwdOverride, language = 'zh', maxFilesShown = 12 } = input
+
+  const resolved = await resolveRepo(cwd, cwdOverride)
+  if ('notRepo' in resolved) {
+    // "git is not installed" and "this directory is not a repository" are
+    // different problems with different fixes; never report one as the other.
+    if (!await gitAvailable()) {
+      return { ok: false, reason: 'git-unavailable', message: '找不到 git 可执行文件，无法提交。请先安装 Git 并确保它在 PATH 中。' }
+    }
+    return { ok: false, notRepo: true, candidates: resolved.candidates }
+  }
+  const root = resolved.root
+
+  const [rawStatus, branch, upstream, head, subjects, diffText] = await Promise.all([
+    status(root),
+    currentBranch(root),
+    hasUpstream(root),
+    headShort(root),
+    recentSubjects(root, 8),
+    rawDiff(root),
+  ])
+
+  const entries = normalizeEntries(rawStatus)
+  if (entries.length === 0) {
+    return { ok: false, reason: 'clean', message: '没有需要提交的改动' }
+  }
+
+  const tracked = await numstat(root, false)
+  const stats = new Map(tracked)
+  for (const entry of entries) {
+    if (!stats.has(entry.path)) stats.set(entry.path, { added: 0, deleted: 0, binary: false })
+  }
+
+  const breaking = removedDeclarationCount(diffText) > 0
+  const versionFiles = entries.map(entry => entry.path).filter(path => VERSION_FILE.test(path))
+
+  // A version bump is only detectable once the file is staged, so stage the
+  // version-carrying files and then re-read the index. The commit path stages
+  // the whole working tree afterwards, so this never narrows what gets committed.
+  let version
+  if (versionFiles.length > 0) {
+    try {
+      await git(root, ['add', '-A', '--', ...versionFiles], { timeoutMs: 20_000 })
+    } catch {
+      // Best effort: an unstaged version file only means no tag is suggested.
+    }
+    version = await detectVersion(root, versionFiles)
+  }
+
+  const draft = buildMessage({
+    entries: entries.map(entry => ({ status: entry.status, path: entry.path, ...(entry.origPath === undefined ? {} : { origPath: entry.origPath }) })),
+    stats,
+    unifiedDiff: diffText,
+    recentSubjects: subjects,
+    language,
+    maxFiles: maxFilesShown,
+  })
+
+  return {
+    ok: true,
+    root,
+    branch,
+    entries,
+    stats,
+    recentSubjects: subjects,
+    ...(version === undefined ? {} : { version }),
+    breaking,
+    draft,
+    hasUpstream: upstream,
+    ...(head === undefined ? {} : { head }),
+    unifiedDiff: diffText,
+  }
+}
+
+/** Re-exported so callers can classify a path without importing analyze.js. */
+export { typeOfPath, scopeOf, declaredSymbols }
+
+/** Whether `dir` is a work-tree root, for the container-cwd error message. */
+export { isRepo, repoRoot }

package/lib/test-fixture.mjs

@@ -0,0 +1,64 @@
+/**
+ * A throwaway git repository for tests.
+ *
+ * Everything lives under the OS temp directory and is removed on cleanup, so a
+ * test run can exercise real git without touching any repository the user
+ * cares about. Git's global and system config are disabled inside the fixture,
+ * which makes the commit identity explicit and keeps a user's `commit.gpgsign`,
+ * hooks or templates from leaking into a test.
+ */
+import { execFileSync } from 'node:child_process'
+import { mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { isolatedGitEnv } from './git.js'
+
+/** Deterministic identity so a fixture never depends on the machine's config. */
+const IDENTITY = { name: 'dsh-plugin-test', email: 'test@example.invalid' }
+
+/**
+ * Create a repository with one empty commit in a fresh temp directory.
+ *
+ * @param {string} [prefix] temp-directory prefix, for readable diagnostics
+ * @returns {{ dir: string, git: (args: string[]) => string, write: (path: string, text: string) => void, rename: (from: string, to: string) => void, remove: (path: string) => void, commitAll: (message: string) => void, cleanup: () => void }}
+ */
+export function createFixtureRepo(prefix = 'git-commit-push-fixture-') {
+  const dir = mkdtempSync(join(tmpdir(), prefix))
+  // `isolatedGitEnv()` carries the per-platform `/dev/null` spelling too, which
+  // is what keeps this fixture correct on Windows.
+  const env = isolatedGitEnv()
+
+  /** Run one git command in the fixture and return stdout. */
+  const git = args => execFileSync('git', args, { cwd: dir, encoding: 'utf8', env })
+
+  /** Run git with the fixture's pinned identity (only commits need one). */
+  const committed = args => git([
+    '-c', `user.name=${IDENTITY.name}`, '-c', `user.email=${IDENTITY.email}`, ...args,
+  ])
+
+  git(['init', '-q', '-b', 'main'])
+  committed(['commit', '-q', '--allow-empty', '-m', 'chore: init'])
+
+  return {
+    dir,
+    git,
+    write(path, text) {
+      const absolute = join(dir, path)
+      mkdirSync(dirname(absolute), { recursive: true })
+      writeFileSync(absolute, text)
+    },
+    rename(from, to) {
+      renameSync(join(dir, from), join(dir, to))
+    },
+    remove(path) {
+      rmSync(join(dir, path), { force: true })
+    },
+    commitAll(message) {
+      git(['add', '-A'])
+      committed(['commit', '-q', '-m', message])
+    },
+    cleanup() {
+      rmSync(dir, { recursive: true, force: true })
+    },
+  }
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Git commit & push",
+    "description": "One call commits and pushes: surveys the working tree, writes a Conventional Commits message, asks about a tag when one is warranted, then pushes. Also ships a /git-commit-push command that runs without the model."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Git 提交与推送",
+    "description": "一次调用完成「提交 + 推送」：汇总改动、按 Conventional Commits 生成提交信息、必要时询问打标签，然后推送。另附不经过模型的 /git-commit-push 斜杠命令。"
+  }
+}

package/package.json

@@ -1,6 +1,83 @@
 {
   "name": "dsh-plugin-git-commit-push",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "One-call Conventional-Commits git workflow for DeepSeek Harness: survey + commit + optional tag + push, plus a /git-commit-push slash command that runs with no model involvement. Windows and macOS/Linux.",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json",
+    "./locale/*": "./locale/*"
+  },
+  "icon": "./icon.svg",
+  "dsh": {
+    "manifestVersion": 1,
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "engines": {
+    "node": ">=22.23.0",
+    "dsh": ">=0.2.0-rc.1 <0.3.0"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.4"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-tools": "^0.2.0-rc.1"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "test": "node self-test.mjs && node self-test-git.mjs",
+    "probe": "node capture-git-format.mjs",
+    "prepublishOnly": "node self-test.mjs && node self-test-git.mjs"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek",
+    "deepseek-harness",
+    "cordis-plugin",
+    "git",
+    "commit",
+    "push",
+    "conventional-commits",
+    "tag",
+    "agent"
+  ],
+  "author": "ygzhang <ygzhang.cn@msn.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ygzhang-lab/dsh-plugin-git-commit-push.git"
+  },
+  "homepage": "https://github.com/ygzhang-lab/dsh-plugin-git-commit-push#readme",
+  "bugs": {
+    "url": "https://github.com/ygzhang-lab/dsh-plugin-git-commit-push/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "index.js",
+    "lib",
+    "cordis.patch.yml",
+    "locale",
+    "icon.svg",
+    "git-commit-push.config.json",
+    "setup.ps1",
+    "setup.sh",
+    "self-test.mjs",
+    "self-test-git.mjs",
+    "capture-git-format.mjs",
+    "e2e-check.mjs",
+    "SKILL.md",
+    "README.md",
+    "README.en.md"
+  ]
+}