@harness-engineering/cli 1.8.2 → 1.10.0

package/dist/chunk-7X7ZAYMY.js

@@ -0,0 +1,373 @@
+import {
+  logger
+} from "./chunk-HIOXKZYF.js";
+import {
+  CLIError,
+  ExitCode
+} from "./chunk-B7HFEHWP.js";
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/commands/check-phase-gate.ts
+import { Command } from "commander";
+import * as path2 from "path";
+import * as fs2 from "fs";
+
+// src/config/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/config/schema.ts
+import { z } from "zod";
+var LayerSchema = z.object({
+  name: z.string(),
+  pattern: z.string(),
+  allowedDependencies: z.array(z.string())
+});
+var ForbiddenImportSchema = z.object({
+  from: z.string(),
+  disallow: z.array(z.string()),
+  message: z.string().optional()
+});
+var BoundaryConfigSchema = z.object({
+  requireSchema: z.array(z.string())
+});
+var AgentConfigSchema = z.object({
+  executor: z.enum(["subprocess", "cloud", "noop"]).default("subprocess"),
+  timeout: z.number().default(3e5),
+  skills: z.array(z.string()).optional()
+});
+var EntropyConfigSchema = z.object({
+  excludePatterns: z.array(z.string()).default(["**/node_modules/**", "**/*.test.ts"]),
+  autoFix: z.boolean().default(false)
+});
+var PhaseGateMappingSchema = z.object({
+  implPattern: z.string(),
+  specPattern: z.string()
+});
+var PhaseGatesConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  severity: z.enum(["error", "warning"]).default("error"),
+  mappings: z.array(PhaseGateMappingSchema).default([{ implPattern: "src/**/*.ts", specPattern: "docs/changes/{feature}/proposal.md" }])
+});
+var SecurityConfigSchema = z.object({
+  enabled: z.boolean().default(true),
+  strict: z.boolean().default(false),
+  rules: z.record(z.string(), z.enum(["off", "error", "warning", "info"])).optional(),
+  exclude: z.array(z.string()).optional()
+}).passthrough();
+var PerformanceConfigSchema = z.object({
+  complexity: z.record(z.unknown()).optional(),
+  coupling: z.record(z.unknown()).optional(),
+  sizeBudget: z.record(z.unknown()).optional()
+}).passthrough();
+var DesignConfigSchema = z.object({
+  strictness: z.enum(["strict", "standard", "permissive"]).default("standard"),
+  platforms: z.array(z.enum(["web", "mobile"])).default([]),
+  tokenPath: z.string().optional(),
+  aestheticIntent: z.string().optional()
+});
+var I18nCoverageConfigSchema = z.object({
+  minimumPercent: z.number().min(0).max(100).default(100),
+  requirePlurals: z.boolean().default(true),
+  detectUntranslated: z.boolean().default(true)
+});
+var I18nMcpConfigSchema = z.object({
+  server: z.string(),
+  projectId: z.string().optional()
+});
+var I18nConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  strictness: z.enum(["strict", "standard", "permissive"]).default("standard"),
+  sourceLocale: z.string().default("en"),
+  targetLocales: z.array(z.string()).default([]),
+  framework: z.enum([
+    "auto",
+    "i18next",
+    "react-intl",
+    "vue-i18n",
+    "flutter-intl",
+    "apple",
+    "android",
+    "custom"
+  ]).default("auto"),
+  format: z.string().default("json"),
+  messageFormat: z.enum(["icu", "i18next", "custom"]).default("icu"),
+  keyConvention: z.enum(["dot-notation", "snake_case", "camelCase", "custom"]).default("dot-notation"),
+  translationPaths: z.record(z.string(), z.string()).optional(),
+  platforms: z.array(z.enum(["web", "mobile", "backend"])).default([]),
+  industry: z.string().optional(),
+  coverage: I18nCoverageConfigSchema.optional(),
+  pseudoLocale: z.string().optional(),
+  mcp: I18nMcpConfigSchema.optional()
+});
+var ModelTierConfigSchema = z.object({
+  fast: z.string().optional(),
+  standard: z.string().optional(),
+  strong: z.string().optional()
+});
+var ReviewConfigSchema = z.object({
+  model_tiers: ModelTierConfigSchema.optional()
+});
+var HarnessConfigSchema = z.object({
+  version: z.literal(1),
+  name: z.string().optional(),
+  rootDir: z.string().default("."),
+  layers: z.array(LayerSchema).optional(),
+  forbiddenImports: z.array(ForbiddenImportSchema).optional(),
+  boundaries: BoundaryConfigSchema.optional(),
+  agentsMapPath: z.string().default("./AGENTS.md"),
+  docsDir: z.string().default("./docs"),
+  agent: AgentConfigSchema.optional(),
+  entropy: EntropyConfigSchema.optional(),
+  security: SecurityConfigSchema.optional(),
+  performance: PerformanceConfigSchema.optional(),
+  template: z.object({
+    level: z.enum(["basic", "intermediate", "advanced"]),
+    framework: z.string().optional(),
+    version: z.number()
+  }).optional(),
+  phaseGates: PhaseGatesConfigSchema.optional(),
+  design: DesignConfigSchema.optional(),
+  i18n: I18nConfigSchema.optional(),
+  review: ReviewConfigSchema.optional(),
+  updateCheckInterval: z.number().int().min(0).optional()
+});
+
+// src/config/loader.ts
+var CONFIG_FILENAMES = ["harness.config.json"];
+function findConfigFile(startDir = process.cwd()) {
+  let currentDir = path.resolve(startDir);
+  const root = path.parse(currentDir).root;
+  while (currentDir !== root) {
+    for (const filename of CONFIG_FILENAMES) {
+      const configPath = path.join(currentDir, filename);
+      if (fs.existsSync(configPath)) {
+        return Ok(configPath);
+      }
+    }
+    currentDir = path.dirname(currentDir);
+  }
+  return Err(
+    new CLIError('No harness.config.json found. Run "harness init" to create one.', ExitCode.ERROR)
+  );
+}
+function loadConfig(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return Err(new CLIError(`Config file not found: ${configPath}`, ExitCode.ERROR));
+  }
+  let rawConfig;
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    rawConfig = JSON.parse(content);
+  } catch (error) {
+    return Err(
+      new CLIError(
+        `Failed to parse config: ${error instanceof Error ? error.message : "Unknown error"}`,
+        ExitCode.ERROR
+      )
+    );
+  }
+  const parsed = HarnessConfigSchema.safeParse(rawConfig);
+  if (!parsed.success) {
+    const issues = parsed.error.issues.map((i) => `  - ${i.path.join(".")}: ${i.message}`).join("\n");
+    return Err(new CLIError(`Invalid config:
+${issues}`, ExitCode.ERROR));
+  }
+  return Ok(parsed.data);
+}
+function resolveConfig(configPath) {
+  if (configPath) {
+    return loadConfig(configPath);
+  }
+  const findResult = findConfigFile();
+  if (!findResult.ok) {
+    return findResult;
+  }
+  return loadConfig(findResult.value);
+}
+
+// src/utils/files.ts
+import { glob } from "glob";
+async function findFiles(pattern, cwd = process.cwd()) {
+  return glob(pattern, { cwd, absolute: true });
+}
+
+// src/output/formatter.ts
+import chalk from "chalk";
+var OutputMode = {
+  JSON: "json",
+  TEXT: "text",
+  QUIET: "quiet",
+  VERBOSE: "verbose"
+};
+var OutputFormatter = class {
+  constructor(mode = OutputMode.TEXT) {
+    this.mode = mode;
+  }
+  /**
+   * Format raw data (for JSON mode)
+   */
+  format(data) {
+    if (this.mode === OutputMode.JSON) {
+      return JSON.stringify(data, null, 2);
+    }
+    return String(data);
+  }
+  /**
+   * Format validation result
+   */
+  formatValidation(result) {
+    if (this.mode === OutputMode.JSON) {
+      return JSON.stringify(result, null, 2);
+    }
+    if (this.mode === OutputMode.QUIET) {
+      if (result.valid) return "";
+      return result.issues.map((i) => `${i.file ?? ""}: ${i.message}`).join("\n");
+    }
+    const lines = [];
+    if (result.valid) {
+      lines.push(chalk.green("v validation passed"));
+    } else {
+      lines.push(chalk.red(`x Validation failed (${result.issues.length} issues)`));
+      lines.push("");
+      for (const issue of result.issues) {
+        const location = issue.file ? issue.line ? `${issue.file}:${issue.line}` : issue.file : "unknown";
+        lines.push(`  ${chalk.yellow("*")} ${chalk.dim(location)}`);
+        lines.push(`    ${issue.message}`);
+        if (issue.suggestion && this.mode === OutputMode.VERBOSE) {
+          lines.push(`    ${chalk.dim("->")} ${issue.suggestion}`);
+        }
+      }
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format a summary line
+   */
+  formatSummary(label, value, success) {
+    if (this.mode === OutputMode.JSON || this.mode === OutputMode.QUIET) {
+      return "";
+    }
+    const icon = success ? chalk.green("v") : chalk.red("x");
+    return `${icon} ${label}: ${value}`;
+  }
+};
+
+// src/commands/check-phase-gate.ts
+function resolveSpecPath(implFile, implPattern, specPattern, cwd) {
+  const relImpl = path2.relative(cwd, implFile).replace(/\\/g, "/");
+  const implBase = (implPattern.split("*")[0] ?? "").replace(/\/+$/, "");
+  const afterBase = relImpl.startsWith(implBase + "/") ? relImpl.slice(implBase.length + 1) : relImpl;
+  const segments = afterBase.split("/");
+  const firstSegment = segments[0] ?? "";
+  const feature = segments.length > 1 ? firstSegment : path2.basename(firstSegment, path2.extname(firstSegment));
+  const specRelative = specPattern.replace("{feature}", feature);
+  return path2.resolve(cwd, specRelative);
+}
+async function runCheckPhaseGate(options) {
+  const configResult = resolveConfig(options.configPath);
+  if (!configResult.ok) {
+    return configResult;
+  }
+  const config = configResult.value;
+  const cwd = options.cwd ?? (options.configPath ? path2.dirname(path2.resolve(options.configPath)) : process.cwd());
+  if (!config.phaseGates?.enabled) {
+    return Ok({
+      pass: true,
+      skipped: true,
+      missingSpecs: [],
+      checkedFiles: 0
+    });
+  }
+  const phaseGates = config.phaseGates;
+  const missingSpecs = [];
+  let checkedFiles = 0;
+  for (const mapping of phaseGates.mappings) {
+    const implFiles = await findFiles(mapping.implPattern, cwd);
+    for (const implFile of implFiles) {
+      checkedFiles++;
+      const expectedSpec = resolveSpecPath(implFile, mapping.implPattern, mapping.specPattern, cwd);
+      if (!fs2.existsSync(expectedSpec)) {
+        missingSpecs.push({
+          implFile: path2.relative(cwd, implFile).replace(/\\/g, "/"),
+          expectedSpec: path2.relative(cwd, expectedSpec).replace(/\\/g, "/")
+        });
+      }
+    }
+  }
+  const pass = missingSpecs.length === 0;
+  return Ok({
+    pass,
+    skipped: false,
+    severity: phaseGates.severity,
+    missingSpecs,
+    checkedFiles
+  });
+}
+function createCheckPhaseGateCommand() {
+  const command = new Command("check-phase-gate").description("Verify that implementation files have matching spec documents").action(async (_opts, cmd) => {
+    const globalOpts = cmd.optsWithGlobals();
+    const mode = globalOpts.json ? OutputMode.JSON : globalOpts.quiet ? OutputMode.QUIET : globalOpts.verbose ? OutputMode.VERBOSE : OutputMode.TEXT;
+    const formatter = new OutputFormatter(mode);
+    const result = await runCheckPhaseGate({
+      configPath: globalOpts.config,
+      json: globalOpts.json,
+      verbose: globalOpts.verbose,
+      quiet: globalOpts.quiet
+    });
+    if (!result.ok) {
+      if (mode === OutputMode.JSON) {
+        console.log(JSON.stringify({ error: result.error.message }));
+      } else {
+        logger.error(result.error.message);
+      }
+      process.exit(result.error.exitCode);
+    }
+    const value = result.value;
+    if (value.skipped) {
+      if (mode === OutputMode.JSON) {
+        console.log(formatter.format(value));
+      } else if (mode !== OutputMode.QUIET) {
+        logger.dim("Phase gates not enabled, skipping.");
+      }
+      process.exit(ExitCode.SUCCESS);
+    }
+    const output = formatter.formatValidation({
+      valid: value.pass,
+      issues: value.missingSpecs.map((m) => ({
+        file: m.implFile,
+        message: `Missing spec: ${m.expectedSpec}`
+      }))
+    });
+    if (output) {
+      console.log(output);
+    }
+    const summary = formatter.formatSummary(
+      "Phase gate check",
+      `${value.checkedFiles} files checked, ${value.missingSpecs.length} missing specs`,
+      value.pass
+    );
+    if (summary) {
+      console.log(summary);
+    }
+    if (!value.pass && value.severity === "error") {
+      process.exit(ExitCode.VALIDATION_FAILED);
+    }
+    process.exit(ExitCode.SUCCESS);
+  });
+  return command;
+}
+
+export {
+  findConfigFile,
+  loadConfig,
+  resolveConfig,
+  OutputMode,
+  OutputFormatter,
+  findFiles,
+  runCheckPhaseGate,
+  createCheckPhaseGateCommand
+};

package/dist/chunk-B7HFEHWP.js

@@ -0,0 +1,35 @@
+// src/utils/errors.ts
+var ExitCode = {
+  SUCCESS: 0,
+  VALIDATION_FAILED: 1,
+  ERROR: 2
+};
+var CLIError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = ExitCode.ERROR) {
+    super(message);
+    this.name = "CLIError";
+    this.exitCode = exitCode;
+  }
+};
+function formatError(error) {
+  if (error instanceof CLIError) {
+    return `Error: ${error.message}`;
+  }
+  if (error instanceof Error) {
+    return `Error: ${error.message}`;
+  }
+  return `Error: ${String(error)}`;
+}
+function handleError(error) {
+  const message = formatError(error);
+  console.error(message);
+  const exitCode = error instanceof CLIError ? error.exitCode : ExitCode.ERROR;
+  process.exit(exitCode);
+}
+
+export {
+  ExitCode,
+  CLIError,
+  handleError
+};

package/dist/chunk-BM3PWGXQ.js

@@ -0,0 +1,14 @@
+// src/version.ts
+import { createRequire } from "module";
+var require_ = createRequire(import.meta.url);
+var resolved;
+try {
+  resolved = require_("../package.json").version ?? "0.0.0";
+} catch {
+  resolved = "0.0.0";
+}
+var CLI_VERSION = resolved;
+
+export {
+  CLI_VERSION
+};

package/dist/chunk-C2ERUR3L.js

@@ -0,0 +1,255 @@
+import {
+  Err,
+  Ok
+} from "./chunk-MHBMTPW7.js";
+
+// src/templates/engine.ts
+import * as fs from "fs";
+import * as path from "path";
+import Handlebars from "handlebars";
+
+// src/templates/schema.ts
+import { z } from "zod";
+var MergeStrategySchema = z.object({
+  json: z.enum(["deep-merge", "overlay-wins"]).default("deep-merge"),
+  files: z.literal("overlay-wins").default("overlay-wins")
+});
+var TemplateMetadataSchema = z.object({
+  name: z.string(),
+  description: z.string(),
+  level: z.enum(["basic", "intermediate", "advanced"]).optional(),
+  framework: z.string().optional(),
+  extends: z.string().optional(),
+  mergeStrategy: MergeStrategySchema.default({}),
+  version: z.literal(1)
+});
+
+// src/templates/merger.ts
+function isPlainObject(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+function deepMergeJson(base, overlay) {
+  const result = { ...base };
+  for (const key of Object.keys(overlay)) {
+    if (isPlainObject(result[key]) && isPlainObject(overlay[key])) {
+      result[key] = deepMergeJson(
+        result[key],
+        overlay[key]
+      );
+    } else {
+      result[key] = overlay[key];
+    }
+  }
+  return result;
+}
+var CONCAT_KEYS = /* @__PURE__ */ new Set(["dependencies", "devDependencies", "peerDependencies"]);
+function mergePackageJson(base, overlay) {
+  const result = { ...base };
+  for (const key of Object.keys(overlay)) {
+    if (CONCAT_KEYS.has(key) && isPlainObject(result[key]) && isPlainObject(overlay[key])) {
+      result[key] = {
+        ...result[key],
+        ...overlay[key]
+      };
+    } else if (isPlainObject(result[key]) && isPlainObject(overlay[key])) {
+      result[key] = deepMergeJson(
+        result[key],
+        overlay[key]
+      );
+    } else {
+      result[key] = overlay[key];
+    }
+  }
+  return result;
+}
+
+// src/templates/engine.ts
+var TemplateEngine = class {
+  constructor(templatesDir) {
+    this.templatesDir = templatesDir;
+  }
+  listTemplates() {
+    try {
+      const entries = fs.readdirSync(this.templatesDir, { withFileTypes: true });
+      const templates = [];
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const metaPath = path.join(this.templatesDir, entry.name, "template.json");
+        if (!fs.existsSync(metaPath)) continue;
+        const raw = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+        const parsed = TemplateMetadataSchema.safeParse(raw);
+        if (parsed.success) templates.push(parsed.data);
+      }
+      return Ok(templates);
+    } catch (error) {
+      return Err(
+        new Error(
+          `Failed to list templates: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+    }
+  }
+  resolveTemplate(level, framework) {
+    const levelDir = this.findTemplateDir(level, "level");
+    if (!levelDir) return Err(new Error(`Template not found for level: ${level}`));
+    const metaPath = path.join(levelDir, "template.json");
+    const metaRaw = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+    const metaResult = TemplateMetadataSchema.safeParse(metaRaw);
+    if (!metaResult.success)
+      return Err(new Error(`Invalid template.json in ${level}: ${metaResult.error.message}`));
+    const metadata = metaResult.data;
+    let files = [];
+    if (metadata.extends) {
+      const baseDir = path.join(this.templatesDir, metadata.extends);
+      if (fs.existsSync(baseDir)) files = this.collectFiles(baseDir, metadata.extends);
+    }
+    const levelFiles = this.collectFiles(levelDir, level);
+    files = this.mergeFileLists(files, levelFiles);
+    let overlayMetadata;
+    if (framework) {
+      const frameworkDir = this.findTemplateDir(framework, "framework");
+      if (!frameworkDir) return Err(new Error(`Framework template not found: ${framework}`));
+      const fMetaPath = path.join(frameworkDir, "template.json");
+      const fMetaRaw = JSON.parse(fs.readFileSync(fMetaPath, "utf-8"));
+      const fMetaResult = TemplateMetadataSchema.safeParse(fMetaRaw);
+      if (fMetaResult.success) overlayMetadata = fMetaResult.data;
+      const frameworkFiles = this.collectFiles(frameworkDir, framework);
+      files = this.mergeFileLists(files, frameworkFiles);
+    }
+    files = files.filter((f) => f.relativePath !== "template.json");
+    const resolved = { metadata, files };
+    if (overlayMetadata !== void 0) resolved.overlayMetadata = overlayMetadata;
+    return Ok(resolved);
+  }
+  render(template, context) {
+    const rendered = [];
+    const jsonBuffers = /* @__PURE__ */ new Map();
+    for (const file of template.files) {
+      const outputPath = file.relativePath.replace(/\.hbs$/, "");
+      if (file.isHandlebars) {
+        try {
+          const raw = fs.readFileSync(file.absolutePath, "utf-8");
+          const compiled = Handlebars.compile(raw, { strict: true });
+          const content = compiled(context);
+          if (outputPath.endsWith(".json") && file.relativePath.endsWith(".json.hbs")) {
+            if (!jsonBuffers.has(outputPath)) jsonBuffers.set(outputPath, []);
+            jsonBuffers.get(outputPath).push(JSON.parse(content));
+          } else {
+            rendered.push({ relativePath: outputPath, content });
+          }
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          return Err(
+            new Error(
+              `Template render failed in ${file.sourceTemplate}/${file.relativePath}: ${msg}`
+            )
+          );
+        }
+      } else {
+        try {
+          const content = fs.readFileSync(file.absolutePath, "utf-8");
+          rendered.push({ relativePath: file.relativePath, content });
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          return Err(
+            new Error(
+              `Template render failed in ${file.sourceTemplate}/${file.relativePath}: ${msg}`
+            )
+          );
+        }
+      }
+    }
+    try {
+      for (const [outputPath, jsons] of jsonBuffers) {
+        let merged = {};
+        for (const json of jsons) {
+          merged = outputPath === "package.json" ? mergePackageJson(merged, json) : deepMergeJson(merged, json);
+        }
+        rendered.push({ relativePath: outputPath, content: JSON.stringify(merged, null, 2) });
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return Err(new Error(`JSON merge failed: ${msg}`));
+    }
+    return Ok({ files: rendered });
+  }
+  write(files, targetDir, options) {
+    try {
+      const written = [];
+      for (const file of files.files) {
+        const targetPath = path.join(targetDir, file.relativePath);
+        const dir = path.dirname(targetPath);
+        if (!options.overwrite && fs.existsSync(targetPath)) continue;
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(targetPath, file.content);
+        written.push(file.relativePath);
+      }
+      return Ok(written);
+    } catch (error) {
+      return Err(
+        new Error(
+          `Failed to write files: ${error instanceof Error ? error.message : String(error)}`
+        )
+      );
+    }
+  }
+  findTemplateDir(name, type) {
+    const entries = fs.readdirSync(this.templatesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const metaPath = path.join(this.templatesDir, entry.name, "template.json");
+      if (!fs.existsSync(metaPath)) continue;
+      const raw = JSON.parse(fs.readFileSync(metaPath, "utf-8"));
+      const parsed = TemplateMetadataSchema.safeParse(raw);
+      if (!parsed.success) continue;
+      if (type === "level" && parsed.data.level === name)
+        return path.join(this.templatesDir, entry.name);
+      if (type === "framework" && parsed.data.framework === name)
+        return path.join(this.templatesDir, entry.name);
+      if (parsed.data.name === name) return path.join(this.templatesDir, entry.name);
+    }
+    return null;
+  }
+  collectFiles(dir, sourceName) {
+    const files = [];
+    const walk = (currentDir) => {
+      const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+          walk(fullPath);
+        } else {
+          files.push({
+            relativePath: path.relative(dir, fullPath).replace(/\\/g, "/"),
+            absolutePath: fullPath,
+            isHandlebars: entry.name.endsWith(".hbs"),
+            sourceTemplate: sourceName
+          });
+        }
+      }
+    };
+    walk(dir);
+    return files;
+  }
+  mergeFileLists(base, overlay) {
+    const map = /* @__PURE__ */ new Map();
+    for (const file of base) map.set(file.relativePath, file);
+    for (const file of overlay) {
+      if (file.relativePath.endsWith(".json.hbs")) {
+        const baseKey = base.find((f) => f.relativePath === file.relativePath);
+        if (baseKey) {
+          map.set(`__overlay__${file.relativePath}`, file);
+        } else {
+          map.set(file.relativePath, file);
+        }
+      } else {
+        map.set(file.relativePath, file);
+      }
+    }
+    return Array.from(map.values());
+  }
+};
+
+export {
+  TemplateEngine
+};