telo3-ai 5.0.7 → 6.2.0

package/src/activate.js

@@ -0,0 +1,159 @@
+/**
+ * Activation: install the always-on Telo3 contract into project instruction
+ * files so any AI auto-loads it every session — mention "telo3" once, stays on.
+ *
+ * Portable primary: AGENTS.md (auto-read by Cursor, Copilot, Codex, Gemini CLI,
+ * Windsurf, Aider, RooCode, ...). Tool-specific files are belt-and-suspenders.
+ * Idempotent, additive, marker-delimited; never clobbers unrelated content.
+ * @license MIT
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, lstatSync, renameSync, mkdtempSync } from 'node:fs';
+import { join, resolve, relative, dirname, isAbsolute } from 'node:path';
+import { findContextDir } from './find-context.js';
+import { assertSafePath } from './paths.js';
+import { fileURLToPath } from 'node:url';
+import { getVersion } from './version.js';
+
+const SKILL_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const BOOTSTRAP_PATH = join(SKILL_ROOT, 'bootstrap', 'TELO3.md');
+
+const BEGIN_RE = /<!-- TELO3:BEGIN[\s\S]*?<!-- TELO3:END -->/g;
+
+/** Shared instruction files: replace our marked block or append; keep everything else. */
+const SHARED_TARGETS = [
+  'AGENTS.md',
+  'CLAUDE.md',
+  'GEMINI.md',
+  join('.github', 'copilot-instructions.md'),
+];
+
+/** Dedicated rule files: wholly Telo3-managed, with tool-specific frontmatter. */
+const DEDICATED_TARGETS = {
+  [join('.cursor', 'rules', 'telo3.mdc')]: '---\ndescription: Telo3 always-on engineering contract\nalwaysApply: true\n---\n',
+  [join('.windsurf', 'rules', 'telo3.md')]: '---\ntrigger: always_on\n---\n',
+  [join('.clinerules', 'telo3.md')]: '',
+};
+
+const DEFAULT_EXTRA = [join('.cursor', 'rules', 'telo3.mdc')];
+const ALL_EXTRA = Object.keys(DEDICATED_TARGETS);
+
+export function renderContract(projectRoot, skillFile = join(SKILL_ROOT, 'SKILL.md')) {
+  const root = resolve(projectRoot);
+  if (!existsSync(skillFile) || !lstatSync(skillFile).isFile()) throw new Error('Skill entry is missing; install the skill first.');
+  const relSkill = relative(root, skillFile);
+  if (isAbsolute(relSkill)) throw new Error('Skill must be on the same drive; install it inside the project.');
+  const context = findContextDir(root) || join(root, 'project-context');
+  const contextPath = toPosix(relative(root, context)) || '.';
+  const raw = readFileSync(BOOTSTRAP_PATH, 'utf8');
+  const body = raw.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '').trimEnd();
+  const skillPath = toPosix(relSkill) || 'SKILL.md';
+  const block = body.replace(/\{\{VERSION\}\}/g, getVersion()).replace(/\{\{SKILL_PATH\}\}/g, skillPath).replace(/\{\{CONTEXT_PATH\}\}/g, contextPath);
+  return { skillPath, contextPath, block };
+}
+
+function toPosix(p) {
+  return p.split('\\').join('/');
+}
+
+function updateInstruction(path, block, frontmatter = null) {
+  for (let attempt = 0; attempt < 3; attempt++) {
+    assertSafePath(dirname(path), path);
+    const existed = existsSync(path);
+    const current = existed ? readFileSync(path, 'utf8') : '';
+    const managed = BEGIN_RE.test(current);
+    BEGIN_RE.lastIndex = 0;
+    if (frontmatter !== null && existed && !managed) return 'skipped';
+    const next = managed ? current.replace(BEGIN_RE, block) : `${frontmatter || ''}${block}\n${current}`;
+    BEGIN_RE.lastIndex = 0;
+    if (existed && next === current) return 'unchanged';
+    mkdirSync(dirname(path), { recursive: true });
+    if (!existed) {
+      try { writeFileSync(path, next, { flag: 'wx' }); return 'created'; }
+      catch (error) { if (error.code === 'EEXIST') continue; throw error; }
+    }
+    const stage = mkdtempSync(join(dirname(path), '.telo3-write-'));
+    try {
+      const staged = join(stage, 'instructions');
+      writeFileSync(staged, next);
+      // If an editor changed the file while staging, rebuild from the new text.
+      if (readFileSync(path, 'utf8') !== current) continue;
+      assertSafePath(dirname(path), path);
+      renameSync(staged, path);
+      return 'updated';
+    } finally { rmSync(stage, { recursive: true, force: true }); }
+  }
+  throw new Error('Instructions changed concurrently; retry after other edits finish.');
+}
+
+function activateShared(path, block) { return updateInstruction(path, block); }
+function activateDedicated(path, frontmatter, block) { return updateInstruction(path, block, frontmatter); }
+
+export function activate(dir = '.', opts = {}) {
+  const projectRoot = resolve(dir);
+  const skillFile = opts.skillPath
+    ? resolve(opts.skillPath)
+    : join(SKILL_ROOT, 'SKILL.md');
+  const rendered = renderContract(projectRoot, skillFile);
+  const extras = opts.all ? ALL_EXTRA : DEFAULT_EXTRA;
+  const targets = [];
+  // Preflight every target before the first write, including linked parents.
+  for (const rel of [...SHARED_TARGETS, ...extras]) {
+    const path = assertSafePath(projectRoot, join(projectRoot, rel));
+    if (existsSync(path) && !lstatSync(path).isFile()) throw new Error('Instruction target must be a regular file.');
+  }
+  const bridge = rel => {
+    const link = toPosix(relative(dirname(join(projectRoot, rel)), join(projectRoot, 'AGENTS.md')));
+    return `<!-- TELO3:BEGIN v${getVersion()} -->\nApply the Telo3 block in project-root instructions: \`${link}\`. Read once per session/resume, not once per task.\n<!-- TELO3:END -->`;
+  };
+  for (const rel of SHARED_TARGETS) {
+    targets.push({ file: toPosix(rel), action: activateShared(join(projectRoot, rel), rel === 'AGENTS.md' ? rendered.block : bridge(rel)) });
+  }
+  for (const rel of extras) {
+    targets.push({ file: toPosix(rel), action: activateDedicated(join(projectRoot, rel), DEDICATED_TARGETS[rel], bridge(rel)) });
+  }
+  return { dir: projectRoot, ...rendered, targets };
+}
+
+export function deactivate(dir = '.') {
+  const projectRoot = resolve(dir);
+  const targets = [];
+
+  for (const rel of SHARED_TARGETS) {
+    const path = assertSafePath(projectRoot, join(projectRoot, rel));
+    if (!existsSync(path)) {
+      targets.push({ file: toPosix(rel), action: 'absent' });
+      continue;
+    }
+    const current = readFileSync(path, 'utf8');
+    if (!BEGIN_RE.test(current)) {
+      BEGIN_RE.lastIndex = 0;
+      targets.push({ file: toPosix(rel), action: 'absent' });
+      continue;
+    }
+    BEGIN_RE.lastIndex = 0;
+    const next = current.replace(/<!-- TELO3:BEGIN[^>]*-->[\s\S]*?<!-- TELO3:END -->\r?\n?/g, '');
+    writeFileSync(path, next);
+    targets.push({ file: toPosix(rel), action: 'removed' });
+  }
+
+  for (const rel of Object.keys(DEDICATED_TARGETS)) {
+    const path = assertSafePath(projectRoot, join(projectRoot, rel));
+    if (!existsSync(path)) {
+      targets.push({ file: toPosix(rel), action: 'absent' });
+      continue;
+    }
+    const current = readFileSync(path, 'utf8');
+    const managed = BEGIN_RE.test(current);
+    BEGIN_RE.lastIndex = 0;
+    if (!managed) {
+      targets.push({ file: toPosix(rel), action: 'skipped' });
+      continue;
+    }
+    const next = current.replace(/<!-- TELO3:BEGIN[^>]*-->[\s\S]*?<!-- TELO3:END -->\r?\n?/g, '');
+    if (next === '' || next === DEDICATED_TARGETS[rel]) rmSync(path);
+    else writeFileSync(path, next);
+    targets.push({ file: toPosix(rel), action: 'removed' });
+  }
+
+  return { dir: projectRoot, targets };
+}

package/src/context.js

@@ -0,0 +1,72 @@
+/**
+ * Task-scoped context loading: read only what the task needs.
+ * memory.md is always first. Savings are measured, never claimed.
+ * @license MIT
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CONTEXT_DOCS, findContextDir } from './find-context.js';
+import { estimateTokens } from './tokens.js';
+import { redactSecrets } from './validate.js';
+
+const REFERENCE_DIR = new URL('../references/', import.meta.url);
+
+const ALL_DOCS = ['memory.md', 'prd.md', 'architecture.md', 'rules.md', 'design.md', 'tasks.md'];
+
+export const TASK_MAP = {
+  feature: { docs: ['memory.md', 'prd.md', 'architecture.md', 'rules.md'], refs: [] },
+  bugfix: { docs: ['memory.md', 'architecture.md', 'rules.md'], refs: [] },
+  design: { docs: ['memory.md', 'design.md', 'rules.md'], refs: ['ui-quality.md'] },
+  security: { docs: ['memory.md', 'architecture.md', 'rules.md'], refs: ['security-quality.md', 'privacy-compliance.md'] },
+  privacy: { docs: ['memory.md', 'architecture.md'], refs: ['privacy-compliance.md', 'legal-compliance.md'] },
+  legal: { docs: ['memory.md', 'prd.md'], refs: ['legal-compliance.md'] },
+  accessibility: { docs: ['memory.md', 'design.md'], refs: ['accessibility-quality.md'] },
+  seo: { docs: ['memory.md', 'design.md'], refs: ['seo-quality.md', 'performance-quality.md'] },
+  performance: { docs: ['memory.md', 'architecture.md'], refs: ['performance-quality.md'] },
+  docs: { docs: ['memory.md'], refs: ['document-specification.md'] },
+  audit: { docs: [...ALL_DOCS], refs: ['project-audit.md'] },
+  all: { docs: [...ALL_DOCS], refs: [] },
+};
+
+function readIfPresent(path) {
+  return existsSync(path) ? redactSecrets(readFileSync(path, 'utf8')) : null;
+}
+
+export function loadContext(dir, task = 'default') {
+  const contextDir = findContextDir(dir);
+  if (!contextDir) {
+    return { dir: null, docs: [], tokens: 0, totalTokens: 0, savingsPct: 0, referenceTokens: 0, contextTokens: 0, missing: ['project-context'] };
+  }
+
+  const entry = TASK_MAP[task] || { docs: ['memory.md'], refs: [] };
+  const docs = [];
+  const missing = [];
+
+  for (const name of entry.docs) {
+    const content = readIfPresent(join(contextDir, name));
+    if (content === null) { missing.push(name); continue; }
+    docs.push({ name, source: 'context', content, tokens: estimateTokens(content) });
+  }
+  for (const name of entry.refs) {
+    const content = readIfPresent(fileURLToPath(new URL(name, REFERENCE_DIR)));
+    if (content === null) { missing.push(`references/${name}`); continue; }
+    docs.push({ name, source: 'reference', content, tokens: estimateTokens(content) });
+  }
+
+  let totalTokens = 0;
+  for (const name of CONTEXT_DOCS) {
+    const content = readIfPresent(join(contextDir, name));
+    if (content !== null) totalTokens += estimateTokens(content);
+  }
+
+  const referenceTokens = docs.filter(d => d.source === 'reference').reduce((sum, d) => sum + d.tokens, 0);
+  const tokens = docs.reduce((sum, d) => sum + d.tokens, 0);
+  const contextTokens = tokens - referenceTokens;
+  // Compare selective docs + required refs with ALL docs + the SAME refs.
+  // This is an estimated loading reduction, not observed API token usage.
+  totalTokens += referenceTokens;
+  const savingsPct = totalTokens > 0 ? Math.round(((totalTokens - tokens) / totalTokens) * 100) : 0;
+
+  return { dir: contextDir, docs, tokens, totalTokens, savingsPct, referenceTokens, contextTokens, missing };
+}

package/src/find-context.js

@@ -0,0 +1,41 @@
+/**
+ * Locate the project-context directory.
+ * Accepted locations: <root>/project-context, <root>/docs/project-context,
+ * or the six documents directly at <root>.
+ * @license MIT
+ */
+import { existsSync, statSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+
+export const CONTEXT_DOCS = [
+  'prd.md',
+  'architecture.md',
+  'rules.md',
+  'design.md',
+  'tasks.md',
+  'memory.md',
+];
+
+export function findContextDir(dir) {
+  let root = resolve(dir);
+  // Prefer the most complete conventional context at the nearest project level.
+  // Ascend only within the repository; never scan recursively or load personal stores.
+  for (let level = 0; level < 12; level++) {
+    const candidates = [join(root, 'project-context'), join(root, 'docs', 'project-context'), root];
+    let best = null;
+    let count = 0;
+    for (const candidate of candidates) {
+      if (!existsSync(candidate) || !statSync(candidate).isDirectory()) continue;
+      const score = CONTEXT_DOCS.filter(doc => {
+        const file = join(candidate, doc);
+        return existsSync(file) && statSync(file).isFile();
+      }).length;
+      if (score > count) { best = candidate; count = score; }
+    }
+    if (best) return best;
+    const parent = dirname(root);
+    if (parent === root || existsSync(join(root, '.git'))) return null;
+    root = parent;
+  }
+  return null;
+}

package/src/init.js

@@ -0,0 +1,38 @@
+/**
+ * Initialize the six context documents from lean templates.
+ * Never overwrites existing files.
+ * @license MIT
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CONTEXT_DOCS } from './find-context.js';
+import { assertSafePath } from './paths.js';
+
+const TEMPLATE_DIR = new URL('../templates/', import.meta.url);
+
+export function initContext(dir, opts = {}) {
+  const root = resolve(dir);
+  const contextDir = opts.contextDir ?? 'project-context';
+  const target = assertSafePath(root, contextDir === '.' ? root : resolve(root, contextDir));
+  mkdirSync(target, { recursive: true });
+
+  const created = [];
+  const skipped = [];
+  for (const doc of CONTEXT_DOCS) {
+    const dest = assertSafePath(root, join(target, doc));
+    if (existsSync(dest)) {
+      skipped.push(doc);
+      continue;
+    }
+    const template = readFileSync(fileURLToPath(new URL(doc, TEMPLATE_DIR)), 'utf8');
+    try {
+      writeFileSync(dest, template, { flag: 'wx' });
+      created.push(doc);
+    } catch (error) {
+      if (error.code === 'EEXIST') skipped.push(doc);
+      else throw error;
+    }
+  }
+  return { dir: target, created, skipped };
+}

package/src/install.js

@@ -0,0 +1,128 @@
+import { existsSync, lstatSync, readFileSync, readdirSync, mkdirSync, writeFileSync, renameSync, rmSync, mkdtempSync, cpSync } from 'node:fs';
+import { join, resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { assertSafePath } from './paths.js';
+
+const SOURCE = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const MARKER = '.telo3-install.json';
+export const AGENT_DIRS = {
+  agents: '.agents/skills/telo3',
+  codex: '.agents/skills/telo3',
+  qoder: '.qoder/skills/telo3',
+  claude: '.claude/skills/telo3',
+  cursor: '.cursor/skills/telo3',
+  gemini: '.gemini/skills/telo3',
+  copilot: '.github/skills/telo3',
+};
+const FILES = ['SKILL.md', 'LICENSE', 'cli.js', 'index.js'];
+const DIRS = ['bootstrap', 'src', 'templates', 'references', 'hooks'];
+const hash = bytes => createHash('sha256').update(bytes).digest('hex');
+
+function collect(source, rel, output) {
+  const path = join(source, rel);
+  const stat = lstatSync(path);
+  if (stat.isSymbolicLink()) throw new Error('Skill payload must not contain symlinks.');
+  if (stat.isDirectory()) {
+    for (const child of readdirSync(path)) collect(source, `${rel ? `${rel}/` : ''}${child}`, output);
+  } else if (stat.isFile()) output[rel] = readFileSync(path);
+}
+
+function detectAgent(root) {
+  for (const agent of ['qoder', 'claude', 'gemini', 'cursor']) {
+    if (existsSync(join(root, `.${agent}`))) return agent;
+  }
+  return 'agents';
+}
+
+/** Install a self-contained project skill, never dependent on the npx cache. */
+export function installSkill(dir = '.', opts = {}) {
+  const root = resolve(dir);
+  if (!existsSync(root) || !lstatSync(root).isDirectory()) throw new Error('Project directory must exist.');
+  const agent = !opts.agent || opts.agent === 'auto' ? detectAgent(root) : opts.agent;
+  if (!Object.hasOwn(AGENT_DIRS, agent)) throw new Error(`Unknown agent. Choose auto, ${Object.keys(AGENT_DIRS).join(', ')}.`);
+  const target = assertSafePath(root, join(root, AGENT_DIRS[agent]));
+  // A manual/ZIP install can use its own runtime without copying over itself
+  // or inventing an ownership record. External installers still refuse unmanaged copies.
+  if (target === SOURCE) return { dir: target, agent, action: 'unchanged', skillPath: join(target, 'SKILL.md') };
+  const payload = {};
+  for (const rel of [...FILES, ...DIRS]) collect(SOURCE, rel, payload);
+  const pkg = JSON.parse(readFileSync(join(SOURCE, 'package.json'), 'utf8'));
+  // Installed skills need runtime metadata, not publishing scripts or marketing.
+  payload['package.json'] = Buffer.from(`${JSON.stringify({ name: pkg.name, version: pkg.version, type: 'module', main: 'index.js', bin: { telo3: './cli.js' }, engines: pkg.engines, license: pkg.license }, null, 2)}\n`);
+  const hashes = Object.fromEntries(Object.entries(payload).map(([path, bytes]) => [path, hash(bytes)]));
+  const marker = Buffer.from(`${JSON.stringify({ schema: 1, name: 'telo3', version: pkg.version, files: hashes }, null, 2)}\n`);
+
+  let owned = null;
+  if (existsSync(target)) {
+    const manifest = assertSafePath(root, join(target, MARKER));
+    if (!existsSync(manifest)) throw new Error('Unmanaged/user-owned skill directory; refusing to overwrite it.');
+    try { owned = JSON.parse(readFileSync(manifest, 'utf8')); } catch { throw new Error('Invalid install ownership record; refusing to overwrite.'); }
+    if (owned.schema !== 1 || owned.name !== 'telo3' || !owned.files) throw new Error('Unmanaged skill ownership record.');
+    for (const [rel, expected] of Object.entries(owned.files)) {
+      const path = assertSafePath(target, join(target, rel));
+      if (!existsSync(path) || !lstatSync(path).isFile() || hash(readFileSync(path)) !== expected) {
+        throw new Error(`Installed skill was modified (${rel}); preserve your customizations before updating.`);
+      }
+    }
+    if (Object.entries(hashes).every(([rel, expected]) => owned.files[rel] === expected) && Object.keys(owned.files).length === Object.keys(hashes).length) {
+      return { dir: target, agent, action: 'unchanged', skillPath: join(target, 'SKILL.md') };
+    }
+  }
+
+  const parent = dirname(target);
+  mkdirSync(parent, { recursive: true });
+  const lock = `${target}.install-lock`;
+  assertSafePath(root, lock);
+  try { mkdirSync(lock); } catch (error) {
+    if (error.code === 'EEXIST') throw new Error('Another skill installation is active; no files changed.');
+    throw error;
+  }
+  let stage;
+  let backup;
+  try {
+    stage = mkdtempSync(join(parent, '.telo3-stage-'));
+    let existing = null;
+    if (owned) {
+      existing = {};
+      collect(target, '', existing); // Reject links and preserve every user-owned extra file.
+      for (const [rel, expected] of Object.entries(owned.files)) {
+        if (!existing[rel] || hash(existing[rel]) !== expected) throw new Error('Installed skill changed during update.');
+      }
+      for (const rel of Object.keys(payload)) {
+        if (existing[rel] && !Object.hasOwn(owned.files, rel)) throw new Error(`User file conflicts with update: ${rel}`);
+      }
+      cpSync(target, stage, { recursive: true });
+      // Remove only obsolete, unchanged files that this installer owned.
+      for (const rel of Object.keys(owned.files)) {
+        if (!Object.hasOwn(payload, rel)) rmSync(join(stage, rel));
+      }
+    }
+    for (const [rel, bytes] of Object.entries({ ...payload, [MARKER]: marker })) {
+      const dest = join(stage, rel);
+      mkdirSync(dirname(dest), { recursive: true });
+      writeFileSync(dest, bytes);
+    }
+    if (owned) {
+      const latest = {};
+      collect(target, '', latest);
+      if (Object.keys(latest).length !== Object.keys(existing).length || Object.keys(existing).some(rel => !latest[rel] || hash(latest[rel]) !== hash(existing[rel]))) {
+        throw new Error('Skill files changed while staging; no update committed.');
+      }
+      backup = `${stage}.previous`;
+      renameSync(target, backup);
+    } else if (existsSync(target)) throw new Error('Destination appeared during installation; no files overwritten.');
+    try {
+      renameSync(stage, target);
+    } catch (error) {
+      if (backup) { renameSync(backup, target); backup = null; }
+      throw error;
+    }
+    if (backup) { rmSync(backup, { recursive: true, force: true }); backup = null; }
+    return { dir: target, agent, action: owned ? 'updated' : 'created', skillPath: join(target, 'SKILL.md') };
+  } finally {
+    if (stage) rmSync(stage, { recursive: true, force: true });
+    // If rollback itself fails, keep the backup intact for recovery.
+    rmSync(lock, { recursive: true, force: true });
+  }
+}

package/src/paths.js

@@ -0,0 +1,20 @@
+import { lstatSync } from 'node:fs';
+import { resolve, relative, isAbsolute, sep, join } from 'node:path';
+
+/** Reject traversal and linked ancestors before a write can escape its project. */
+export function assertSafePath(root, target) {
+  const base = resolve(root);
+  const rel = relative(base, resolve(target));
+  if (isAbsolute(rel) || rel === '..' || rel.startsWith(`..${sep}`)) {
+    throw new Error('Destination must stay inside the project.');
+  }
+  let current = base;
+  for (const part of ['', ...rel.split(sep).filter(Boolean)]) {
+    current = part ? join(current, part) : current;
+    // existsSync follows links and misses dangling ones; lstat does not.
+    let stat;
+    try { stat = lstatSync(current); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+    if (stat?.isSymbolicLink()) throw new Error('Refusing a symlink/junction in the destination path.');
+  }
+  return resolve(target);
+}

package/src/status.js

@@ -0,0 +1,30 @@
+/**
+ * One-line health summary per document, built on the real validator.
+ * @license MIT
+ */
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { validateContext } from './validate.js';
+
+export function getStatus(dir) {
+  const result = validateContext(dir);
+  if (!result.dir) {
+    return { dir: null, valid: false, errors: result.errors.length, warnings: result.warnings.length, docs: [] };
+  }
+  return {
+    dir: result.dir,
+    valid: result.valid,
+    errors: result.errors.length,
+    warnings: result.warnings.length,
+    docs: result.files.map((f) => ({
+      file: f.file,
+      exists: f.exists,
+      sections: f.sections,
+      missingSections: f.missingSections,
+      placeholders: f.placeholders,
+      secrets: f.secrets.length,
+      staleDays: f.stale,
+      lastUpdated: f.exists ? statSync(join(result.dir, f.file)).mtime.toISOString().slice(0, 10) : null,
+    })),
+  };
+}

package/src/tokens.js

@@ -0,0 +1,10 @@
+/**
+ * Token estimation — deliberately simple and honest (~4 chars/token).
+ * Used for measured per-project savings, never marketing claims.
+ * @license MIT
+ */
+
+export function estimateTokens(text) {
+  if (!text) return 0;
+  return Math.ceil(text.length / 4);
+}