taphound 0.2.0-dev.1 → 0.2.0-dev.12

package/dist/adapters/filesystem/project-inventory-inspector.js

@@ -0,0 +1,93 @@
+import { createHash } from "node:crypto";
+import { readdir, realpath, stat } from "node:fs/promises";
+import { basename, relative, resolve } from "node:path";
+import { errnoCode } from "../../shared/errors.js";
+import { isContained } from "../../shared/paths.js";
+import { compareStrings } from "../../shared/strings.js";
+const EXCLUDED_DIRECTORIES = new Set([
+    ".git",
+    ".gradle",
+    ".idea",
+    ".taphound",
+    "bin",
+    "build",
+    "out"
+]);
+function matches(path, categories) {
+    const normalized = path.replaceAll("\\", "/");
+    return ((categories.has("manifests") && basename(normalized) === "AndroidManifest.xml")
+        || (categories.has("sources")
+            && (normalized.endsWith(".kt") || normalized.endsWith(".java")))
+        || (categories.has("layouts")
+            && /\/res\/layout[^/]*\/[^/]+\.xml$/.test(`/${normalized}`))
+        || (categories.has("navigation")
+            && /\/res\/navigation[^/]*\/[^/]+\.xml$/.test(`/${normalized}`)));
+}
+export class NodeProjectInventoryInspector {
+    inspectProjectInventory = async (input) => {
+        let root;
+        let moduleRoot;
+        try {
+            root = await realpath(input.projectRoot);
+            const rootStats = await stat(root);
+            if (!rootStats.isDirectory()) {
+                return { status: "rootNotDirectory" };
+            }
+            moduleRoot = await realpath(resolve(root, input.projectDir));
+            const moduleStats = await stat(moduleRoot);
+            if (!moduleStats.isDirectory()) {
+                return { status: "rootNotDirectory" };
+            }
+        }
+        catch (error) {
+            return errnoCode(error) === "ENOENT" || errnoCode(error) === "ENOTDIR"
+                ? { status: "rootNotFound" }
+                : { status: "rootUnreadable" };
+        }
+        if (!isContained(root, moduleRoot)) {
+            return { status: "escape" };
+        }
+        const categories = new Set(input.categories);
+        const paths = [];
+        const pending = [moduleRoot];
+        try {
+            while (pending.length > 0) {
+                const directory = pending.pop();
+                if (directory === undefined) {
+                    continue;
+                }
+                const entries = await readdir(directory, { withFileTypes: true });
+                for (const entry of entries) {
+                    const path = resolve(directory, entry.name);
+                    if (entry.isSymbolicLink()) {
+                        continue;
+                    }
+                    if (entry.isDirectory()) {
+                        if (!EXCLUDED_DIRECTORIES.has(entry.name)) {
+                            pending.push(path);
+                        }
+                        continue;
+                    }
+                    if (!entry.isFile()) {
+                        continue;
+                    }
+                    const projectRelative = relative(root, path).replaceAll("\\", "/");
+                    if (matches(projectRelative, categories)) {
+                        paths.push(projectRelative);
+                    }
+                }
+            }
+        }
+        catch {
+            return { status: "rootUnreadable" };
+        }
+        paths.sort((left, right) => compareStrings(left, right));
+        return {
+            status: "inspected",
+            paths,
+            pathSetSha256: createHash("sha256")
+                .update(paths.join("\n"))
+                .digest("hex")
+        };
+    };
+}

package/dist/adapters/filesystem/project-module-discoverer.d.ts

@@ -0,0 +1,6 @@
+import type { ProjectModuleDiscovery, ProjectModuleDiscoverer } from "../../ports/project-module-discoverer.js";
+export declare class GradleProjectModuleDiscoverer implements ProjectModuleDiscoverer {
+    readonly discoverModules: (input: {
+        readonly projectRoot: string;
+    }) => Promise<ProjectModuleDiscovery>;
+}

package/dist/adapters/filesystem/project-module-discoverer.js

@@ -0,0 +1,158 @@
+import { readFile, realpath, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { errnoCode } from "../../shared/errors.js";
+const GRADLE_PATH = "(:[A-Za-z0-9_-]+(?::[A-Za-z0-9_-]+)*)";
+const QUOTED_PATH = new RegExp(`['"]${GRADLE_PATH}['"]`, "g");
+const PAIR_PATTERN = new RegExp(`['"]${GRADLE_PATH}['"]\\s+to\\s+['"]([^'"]+)['"]`, "g");
+const PROJECT_DIR_OVERRIDE = new RegExp(`project\\s*\\(\\s*['"]${GRADLE_PATH}['"]\\s*\\)\\s*\\.\\s*projectDir\\s*=\\s*(?:file|new\\s+File)\\s*\\(\\s*(?:rootDir\\s*,\\s*)?['"]([^'"]+)['"]\\s*\\)`, "g");
+function gradlePathToProjectDir(gradlePath) {
+    return gradlePath.replace(/^:/, "").replace(/:/g, "/");
+}
+function stripRootDirPrefix(dir) {
+    return dir.replace(/^\$\{?rootDir\}?\/+/, "");
+}
+function parseIncludedModules(content) {
+    const moduleMap = new Map();
+    QUOTED_PATH.lastIndex = 0;
+    let match;
+    while ((match = QUOTED_PATH.exec(content)) !== null) {
+        const gradlePath = match[1];
+        if (gradlePath !== undefined) {
+            moduleMap.set(gradlePath, undefined);
+        }
+    }
+    PAIR_PATTERN.lastIndex = 0;
+    while ((match = PAIR_PATTERN.exec(content)) !== null) {
+        const gradlePath = match[1];
+        const dir = match[2];
+        if (gradlePath !== undefined && dir !== undefined) {
+            moduleMap.set(gradlePath, stripRootDirPrefix(dir));
+        }
+    }
+    PROJECT_DIR_OVERRIDE.lastIndex = 0;
+    while ((match = PROJECT_DIR_OVERRIDE.exec(content)) !== null) {
+        const gradlePath = match[1];
+        const dir = match[2];
+        if (gradlePath !== undefined && dir !== undefined) {
+            moduleMap.set(gradlePath, stripRootDirPrefix(dir));
+        }
+    }
+    return [...moduleMap.entries()].map(([gradlePath, explicitDir]) => ({
+        gradlePath,
+        ...(explicitDir === undefined ? {} : { explicitDir })
+    }));
+}
+async function findSettingsFile(projectRoot) {
+    for (const name of ["settings.gradle.kts", "settings.gradle"]) {
+        const candidate = resolve(projectRoot, name);
+        try {
+            const stats = await stat(candidate);
+            if (stats.isFile()) {
+                return candidate;
+            }
+        }
+        catch {
+            // continue
+        }
+    }
+    return undefined;
+}
+async function readBuildFile(moduleDir) {
+    for (const name of ["build.gradle.kts", "build.gradle"]) {
+        const candidate = resolve(moduleDir, name);
+        try {
+            const stats = await stat(candidate);
+            if (stats.isFile()) {
+                return await readFile(candidate, "utf8");
+            }
+        }
+        catch {
+            // continue
+        }
+    }
+    return undefined;
+}
+function detectKind(buildContent) {
+    if (/com\.android\.application/.test(buildContent)
+        || /id\s*\(\s*["'][^"']*android\.application[^"']*["']\s*\)/.test(buildContent)
+        || /apply\s*\(\s*plugin\s*=\s*["'][^"']*android\.application[^"']*["']\s*\)/.test(buildContent)
+        || /alias\s*\([^)]*android\.application[^)]*\)/.test(buildContent)) {
+        return "application";
+    }
+    if (/com\.android\.dynamic-feature/.test(buildContent)
+        || /id\s*\(\s*["'][^"']*android\.dynamic-feature[^"']*["']\s*\)/.test(buildContent)
+        || /alias\s*\([^)]*android\.dynamic-feature[^)]*\)/.test(buildContent)) {
+        return "feature";
+    }
+    return "library";
+}
+function parseDependencies(buildContent) {
+    const deps = [];
+    const pattern = new RegExp(`project\\s*\\(\\s*['"]${GRADLE_PATH}['"]\\s*\\)`, "g");
+    let match;
+    while ((match = pattern.exec(buildContent)) !== null) {
+        const dep = match[1];
+        if (dep !== undefined) {
+            deps.push(dep);
+        }
+    }
+    return [...new Set(deps)];
+}
+export class GradleProjectModuleDiscoverer {
+    discoverModules = async (input) => {
+        let root;
+        try {
+            root = await realpath(input.projectRoot);
+            const rootStats = await stat(root);
+            if (!rootStats.isDirectory()) {
+                return { status: "rootNotDirectory" };
+            }
+        }
+        catch (error) {
+            return errnoCode(error) === "ENOENT"
+                ? { status: "rootNotFound" }
+                : { status: "discoveryFailed", message: "Project root is not accessible" };
+        }
+        const settingsPath = await findSettingsFile(root);
+        if (settingsPath === undefined) {
+            return { status: "noSettingsFile" };
+        }
+        let settingsContent;
+        try {
+            settingsContent = await readFile(settingsPath, "utf8");
+        }
+        catch {
+            return { status: "discoveryFailed", message: "settings file is not readable" };
+        }
+        const includedModules = parseIncludedModules(settingsContent);
+        if (includedModules.length === 0) {
+            return { status: "noApplicationModule" };
+        }
+        const modules = [];
+        for (const { gradlePath, explicitDir } of includedModules) {
+            const projectDir = explicitDir ?? gradlePathToProjectDir(gradlePath);
+            const moduleDir = resolve(root, projectDir);
+            try {
+                const moduleStats = await stat(moduleDir);
+                if (!moduleStats.isDirectory()) {
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            const buildContent = await readBuildFile(moduleDir);
+            const kind = buildContent !== undefined
+                ? detectKind(buildContent)
+                : "library";
+            const dependsOn = buildContent !== undefined
+                ? parseDependencies(buildContent)
+                : [];
+            modules.push({ id: gradlePath, projectDir, kind, dependsOn });
+        }
+        if (!modules.some((module) => module.kind === "application")) {
+            return { status: "noApplicationModule" };
+        }
+        return { status: "discovered", modules };
+    };
+}

package/dist/adapters/filesystem/skill-installer.d.ts

@@ -4,7 +4,12 @@ export declare class SkillPayloadMissingError extends Error {
     readonly name = "SkillPayloadMissingError";
     constructor(payloadPath: string);
 }
+export declare class NoSkillsFoundError extends Error {
+    readonly scannedDir: string;
+    readonly name = "NoSkillsFoundError";
+    constructor(scannedDir: string);
+}
 export declare class FileSystemSkillInstaller implements SkillInstallerPort {
-    findPayload(): Promise<string>;
-    installTo(targetDir: string): Promise<SkillInstallResult>;
+    listSkillNames(): Promise<readonly string[]>;
+    installTo(skillName: string, targetDir: string): Promise<SkillInstallResult>;
 }

package/dist/adapters/filesystem/skill-installer.js

@@ -1,10 +1,9 @@
-import { access, cp, mkdir } from "node:fs/promises";
+import { access, cp, mkdir, readdir, stat } from "node:fs/promises";
 import { constants } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { SKILL_DIRECTORY_NAME } from "../../domain/init.js";
 const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
-const PAYLOAD_PATH = resolve(PACKAGE_ROOT, "assets", "skills", SKILL_DIRECTORY_NAME);
+const SKILLS_DIR = resolve(PACKAGE_ROOT, "assets", "skills");
 export class SkillPayloadMissingError extends Error {
     payloadPath;
     name = "SkillPayloadMissingError";
@@ -13,18 +12,48 @@ export class SkillPayloadMissingError extends Error {
         this.payloadPath = payloadPath;
     }
 }
+export class NoSkillsFoundError extends Error {
+    scannedDir;
+    name = "NoSkillsFoundError";
+    constructor(scannedDir) {
+        super(`No skills (directories with SKILL.md) found under ${scannedDir}`);
+        this.scannedDir = scannedDir;
+    }
+}
 export class FileSystemSkillInstaller {
-    async findPayload() {
+    async listSkillNames() {
+        const entries = await readdir(SKILLS_DIR, { withFileTypes: true });
+        const skillNames = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const skillMd = join(SKILLS_DIR, entry.name, "SKILL.md");
+            try {
+                await access(skillMd, constants.R_OK);
+                skillNames.push(entry.name);
+            }
+            catch {
+                // Not a skill directory (no SKILL.md), skip
+            }
+        }
+        if (skillNames.length === 0) {
+            throw new NoSkillsFoundError(SKILLS_DIR);
+        }
+        return skillNames;
+    }
+    async installTo(skillName, targetDir) {
+        const payloadPath = resolve(SKILLS_DIR, skillName);
         try {
-            await access(PAYLOAD_PATH, constants.R_OK);
+            await access(payloadPath, constants.R_OK);
+            const stats = await stat(payloadPath);
+            if (!stats.isDirectory()) {
+                throw new SkillPayloadMissingError(payloadPath);
+            }
         }
         catch {
-            throw new SkillPayloadMissingError(PAYLOAD_PATH);
+            throw new SkillPayloadMissingError(payloadPath);
         }
-        return PAYLOAD_PATH;
-    }
-    async installTo(targetDir) {
-        const payloadPath = await this.findPayload();
         const resolvedTarget = resolve(targetDir);
         if (resolvedTarget === resolve(payloadPath)) {
             return { targetPath: resolvedTarget, skipped: true };

package/dist/adapters/filesystem/workspace-layout.d.ts

@@ -0,0 +1,7 @@
+import type { WorkspaceLayoutPort } from "../../ports/workspace-layout.js";
+export declare function ensureBuildIgnored(projectRoot: string): Promise<void>;
+export declare function ensureBuildLayout(projectRoot: string): Promise<void>;
+export declare class FileSystemWorkspaceLayout implements WorkspaceLayoutPort {
+    readonly ensureBuildIgnored: (projectRoot: string) => Promise<void>;
+    readonly ensureBuildLayout: (projectRoot: string) => Promise<void>;
+}

package/dist/adapters/filesystem/workspace-layout.js

@@ -0,0 +1,57 @@
+import { constants, lstat, mkdir, open, realpath } from "node:fs/promises";
+import { join } from "node:path";
+import { BUILD_DIR, BUILD_IGNORE_CONTENT, BUILD_IGNORE_FILE, TAPHOUND_DIR } from "../../domain/workspace.js";
+import { isErrnoException } from "../../shared/errors.js";
+export async function ensureBuildIgnored(projectRoot) {
+    let handle;
+    try {
+        handle = await open(join(projectRoot, BUILD_IGNORE_FILE), constants.O_WRONLY
+            | constants.O_CREAT
+            | constants.O_EXCL
+            | constants.O_NOFOLLOW, 0o644);
+        await handle.writeFile(BUILD_IGNORE_CONTENT, "utf8");
+        await handle.sync();
+    }
+    catch (error) {
+        // A file the developer already owns is never rewritten.
+        if (!isErrnoException(error) || error.code !== "EEXIST") {
+            throw error;
+        }
+    }
+    finally {
+        await handle?.close();
+    }
+}
+async function createOrRequireDirectory(path) {
+    try {
+        await mkdir(path);
+    }
+    catch (error) {
+        if (!isErrnoException(error) || error.code !== "EEXIST") {
+            throw error;
+        }
+    }
+    const stats = await lstat(path);
+    if (!stats.isDirectory() || stats.isSymbolicLink()) {
+        throw new Error(`Workspace path is not a safe directory: ${path}`);
+    }
+}
+export async function ensureBuildLayout(projectRoot) {
+    const canonicalRoot = await realpath(projectRoot);
+    const rootStats = await lstat(canonicalRoot);
+    if (!rootStats.isDirectory() || rootStats.isSymbolicLink()) {
+        throw new Error(`Project root is not a safe directory: ${projectRoot}`);
+    }
+    const taphoundDirectory = join(canonicalRoot, TAPHOUND_DIR);
+    await createOrRequireDirectory(taphoundDirectory);
+    await createOrRequireDirectory(join(canonicalRoot, BUILD_DIR));
+    await ensureBuildIgnored(canonicalRoot);
+}
+export class FileSystemWorkspaceLayout {
+    ensureBuildIgnored = async (projectRoot) => {
+        await ensureBuildIgnored(projectRoot);
+    };
+    ensureBuildLayout = async (projectRoot) => {
+        await ensureBuildLayout(projectRoot);
+    };
+}

package/dist/adapters/git/node-git-diff.d.ts

@@ -0,0 +1,17 @@
+import { type ChangeSet } from "../../domain/impact.js";
+import type { GitDiffPort } from "../../ports/git-diff.js";
+import type { ProcessRunner } from "../../ports/process-runner.js";
+export declare class NodeGitDiff implements GitDiffPort {
+    private readonly runner;
+    constructor(runner: ProcessRunner);
+    diff(input: {
+        projectRoot: string;
+        base: string;
+        head: string;
+        signal?: AbortSignal | undefined;
+    }): Promise<ChangeSet>;
+    private readonly assertGitRoot;
+    private readonly assertRef;
+    private readonly runGit;
+    private readonly parse;
+}

package/dist/adapters/git/node-git-diff.js

@@ -0,0 +1,114 @@
+import { ChangeSetSchema } from "../../domain/impact.js";
+const NAME_STATUS_RE = /^(\w+)\t(.*)$/;
+function parseStatus(token) {
+    if (token.startsWith("A"))
+        return "added";
+    if (token.startsWith("D"))
+        return "deleted";
+    if (token.startsWith("R"))
+        return "renamed";
+    if (token.startsWith("C"))
+        return "added";
+    return "modified";
+}
+class GitDiffError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "GitDiffError";
+        this.code = code;
+    }
+}
+function failed(result) {
+    if (result.exitCode !== 0 || result.timedOut || result.cancelled) {
+        return result.stderr.trim()
+            || result.spawnError
+            || "git command failed";
+    }
+    return undefined;
+}
+export class NodeGitDiff {
+    runner;
+    constructor(runner) {
+        this.runner = runner;
+    }
+    async diff(input) {
+        const root = input.projectRoot;
+        const signal = input.signal;
+        await this.assertGitRoot(root, signal);
+        await this.assertRef(root, input.base, signal);
+        const head = input.head;
+        if (head !== "WORKTREE") {
+            await this.assertRef(root, head, signal);
+        }
+        const diffArg = head === "WORKTREE"
+            ? input.base
+            : `${input.base}...${head}`;
+        const result = await this.runGit(root, ["diff", "--name-status", "-M", "--no-ext-diff", diffArg], signal);
+        const message = failed(result);
+        if (message !== undefined) {
+            throw new Error(message);
+        }
+        const files = this.parse(result.stdout);
+        if (files.length === 0) {
+            return { version: 1, base: input.base, head, files };
+        }
+        return ChangeSetSchema.parse({
+            version: 1,
+            base: input.base,
+            head,
+            files
+        });
+    }
+    assertGitRoot = async (root, signal) => {
+        const result = await this.runGit(root, ["rev-parse", "--is-inside-work-tree"], signal);
+        const message = failed(result);
+        if (message !== undefined) {
+            throw new GitDiffError("GIT_ROOT_NOT_FOUND", `${root} is not inside a Git work tree`);
+        }
+    };
+    assertRef = async (root, ref, signal) => {
+        const result = await this.runGit(root, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], signal);
+        const message = failed(result);
+        if (message !== undefined) {
+            throw new GitDiffError("GIT_REF_INVALID", `${ref} is not a valid Git ref`);
+        }
+    };
+    runGit = (root, args, signal) => this.runner.run({
+        executable: "git",
+        args: ["-C", root, ...args],
+        ...(signal === undefined ? {} : { signal })
+    });
+    parse = (stdout) => {
+        const files = [];
+        for (const line of stdout.split("\n")) {
+            if (line === "")
+                continue;
+            const match = NAME_STATUS_RE.exec(line);
+            if (match === null) {
+                throw new Error(`git diff returned an unparsable line: ${line}`);
+            }
+            const statusToken = match[1];
+            const rest = match[2];
+            if (statusToken === undefined || rest === undefined) {
+                throw new Error(`git diff returned a malformed line: ${line}`);
+            }
+            const status = parseStatus(statusToken);
+            if (status === "renamed") {
+                const separator = rest.indexOf("\t");
+                if (separator === -1) {
+                    throw new Error(`git diff returned a malformed rename line: ${line}`);
+                }
+                files.push({
+                    path: rest.slice(separator + 1),
+                    oldPath: rest.slice(0, separator),
+                    status
+                });
+            }
+            else {
+                files.push({ path: rest, status });
+            }
+        }
+        return files;
+    };
+}

package/dist/adapters/process/node-detached-process-launcher.d.ts

@@ -0,0 +1,6 @@
+import type { DetachedProcessInput, DetachedProcessLauncher } from "../../ports/detached-process-launcher.js";
+export declare class NodeDetachedProcessLauncher implements DetachedProcessLauncher {
+    readonly launch: (input: DetachedProcessInput) => Promise<{
+        pid: number;
+    }>;
+}

package/dist/adapters/process/node-detached-process-launcher.js

@@ -0,0 +1,96 @@
+import { spawn } from "node:child_process";
+import { mkdir, open } from "node:fs/promises";
+import { dirname } from "node:path";
+const DETACHED_SUPERVISOR = String.raw `
+const { spawn } = require("node:child_process");
+const { open, stat, writeFile } = require("node:fs/promises");
+const input = JSON.parse(process.argv[1]);
+const failure = async (exitCode, signal, message) => {
+  const output = {
+    status: "error",
+    exitCode: typeof exitCode === "number" && exitCode > 0 ? exitCode : 1,
+    failure: {
+      code: "DETACHED_PROCESS_CRASHED",
+      message,
+      details: { exitCode, signal }
+    }
+  };
+  const info = await stat(input.stdoutPath).catch(() => ({ size: 0 }));
+  if (info.size === 0) {
+    await writeFile(input.stdoutPath, JSON.stringify(output) + "\n", "utf8");
+  }
+};
+(async () => {
+  const stdout = await open(input.stdoutPath, "r+");
+  const stderr = await open(input.stderrPath, "r+");
+  let child;
+  try {
+    child = spawn(input.executable, input.args, {
+      cwd: input.cwd,
+      shell: false,
+      stdio: ["ignore", stdout.fd, stderr.fd]
+    });
+    const result = await new Promise((resolve) => {
+      child.once("error", (error) => resolve({ error }));
+      child.once("close", (exitCode, signal) => resolve({ exitCode, signal }));
+    });
+    if (result.error !== undefined) {
+      await failure(null, null, "Detached process failed to start: " + result.error.message);
+    } else if (result.exitCode !== 0 || result.signal !== null) {
+      await failure(
+        result.exitCode,
+        result.signal,
+        result.signal === null
+          ? "Detached process exited before producing a result"
+          : "Detached process terminated by " + result.signal
+      );
+    }
+  } finally {
+    await Promise.all([stdout.close(), stderr.close()]);
+  }
+})().catch(async (error) => {
+  await failure(null, null, "Detached supervisor failed: " + (
+    error instanceof Error ? error.message : String(error)
+  ));
+});
+`;
+export class NodeDetachedProcessLauncher {
+    launch = async (input) => {
+        await Promise.all([
+            mkdir(dirname(input.stdoutPath), { recursive: true }),
+            mkdir(dirname(input.stderrPath), { recursive: true })
+        ]);
+        const stdout = await open(input.stdoutPath, "wx");
+        let stderr;
+        try {
+            stderr = await open(input.stderrPath, "wx");
+            await Promise.all([stdout.close(), stderr.close()]);
+            stderr = undefined;
+            const child = spawn(process.execPath, [
+                "-e",
+                DETACHED_SUPERVISOR,
+                JSON.stringify(input)
+            ], {
+                cwd: input.cwd,
+                detached: true,
+                shell: false,
+                stdio: "ignore"
+            });
+            await new Promise((resolve, reject) => {
+                child.once("spawn", resolve);
+                child.once("error", reject);
+            });
+            if (child.pid === undefined) {
+                throw new Error("Detached generation process did not expose a PID");
+            }
+            child.unref();
+            return { pid: child.pid };
+        }
+        finally {
+            await Promise.all([
+                stdout.close().catch(() => undefined),
+                ...(stderr === undefined ? [] : [stderr.close()])
+            ]);
+        }
+    };
+}