npm - @thanhthi2895/luna-ai - Versions diffs - 2.16.2 - Mend

@thanhthi2895/luna-ai 2.16.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1275) hide show

package/agentic/antigravity/.agents/skills/asana-task/scripts/asana-update-notes.cjs ADDED Viewed

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+/**
+ * asana-update-notes.cjs
+ * Append or replace a named section in an Asana task description via REST API.
+ * Always writes using html_notes to preserve Asana rich text formatting.
+ *
+ * Usage:
+ *   node asana-update-notes.cjs <task-gid> --file <path> --section "Implementation Detail"
+ *   node asana-update-notes.cjs <task-gid> --file <path> --section "QA Testing Instructions"
+ *   echo "<content>" | node asana-update-notes.cjs <task-gid> --section "Implementation Detail"
+ *
+ * Exit codes:
+ *   0 - success
+ *   1 - error
+ *   2 - manual mode (cannot determine update mode)
+ */
+'use strict';
+const fs = require('fs');
+const { requireConfig, apiRequest } = require('./asana-shared.cjs');
+// ─── Plain text → simple HTML wrapper ────────────────────────────────────────
+/**
+ * Convert plain text to basic Asana HTML. Only used to wrap existing
+ * plain-text notes that have no html_notes yet.
+ */
+function plainTextToHtml(text) {
+  const escaped = text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+  return `<body>${escaped}</body>`;
+}
+/**
+ * Minify HTML for Asana. Asana renders every \n as a visible line break,
+ * so we must strip whitespace between tags to avoid unwanted blank lines.
+ */
+function minifyHtml(html) {
+  return html
+    .replace(/>\s+</g, '><')   // Remove whitespace between tags
+    .replace(/\n\s*/g, '')      // Remove all newlines
+    .trim();
+}
+// ─── Section detection & replacement ─────────────────────────────────────────
+/**
+ * Build a regex to find a named section in HTML or plain text.
+ * Matches: <h1-6>Section Name, <strong>Section Name, <b>Section Name, ## Section Name
+ */
+function buildSectionRegex(sectionName) {
+  const escaped = sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(
+    `(?:<h[1-6][^>]*>|<strong[^>]*>|<b[^>]*>|##\\s*)(?:${escaped})`,
+    'i'
+  );
+}
+function hasExistingSection(text, sectionName) {
+  if (!text) return false;
+  return buildSectionRegex(sectionName).test(text) ||
+    new RegExp(sectionName, 'i').test(text);
+}
+function replaceOrAppendHtml(htmlNotes, newContentHtml, sectionName) {
+  const newBodyContent = newContentHtml
+    .replace(/^<body>\n?/i, '')
+    .replace(/\n?<\/body>$/i, '');
+  const separator = '\n\n';
+  const regex = buildSectionRegex(sectionName);
+  const match = regex.exec(htmlNotes || '');
+  if (match) {
+    let before = (htmlNotes || '').substring(0, match.index).trimEnd();
+    before = before.replace(/(<br>|<br\/>|<br \/>)$/i, '').trimEnd();
+    if (!before.includes('<body>')) {
+      before = '<body>\n' + before;
+    }
+    return before + separator + newBodyContent + '\n</body>';
+  }
+  // Append case
+  let base = htmlNotes || '';
+  if (!base) base = '<body>\n</body>';
+  if (base.includes('</body>')) {
+    base = base.replace(/<\/body>\s*$/i, '');
+  } else if (!base.includes('<body>')) {
+    base = `<body>\n${base}`;
+  }
+  return base.trimEnd() + separator + newBodyContent + '\n</body>';
+}
+function replaceOrAppendPlain(notes, newContent, sectionName) {
+  const regex = new RegExp(sectionName, 'i');
+  const match = regex.exec(notes || '');
+  if (match) {
+    const before = (notes || '').substring(0, match.index).trimEnd();
+    return before + '\n\n' + newContent.trim();
+  }
+  return (notes || '').trimEnd() + '\n\n' + newContent.trim();
+}
+// ─── I/O helpers ─────────────────────────────────────────────────────────────
+function exitManualMode(taskGid, content, message) {
+  const taskUrl = `https://app.asana.com/0/0/${taskGid}/f`;
+  console.log(`\nMANUAL MODE: ${message}`);
+  console.log(`Task URL: ${taskUrl}`);
+  console.log('\n--- PASTE THIS CONTENT ---\n');
+  console.log(content);
+  console.log('\n--- END CONTENT ---\n');
+  process.exit(2);
+}
+function readStdin() {
+  return new Promise(resolve => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => (data += chunk));
+    process.stdin.on('end', () => resolve(data.trim()));
+  });
+}
+function extractTaskGid(input) {
+  if (/^\d+$/.test(input)) return input;
+  const newPathMatch = input.match(/\/task\/(\d+)(?:[/?#]|$)/);
+  if (newPathMatch) return newPathMatch[1];
+  const pathMatch = input.match(/app\.asana\.com\/0\/\d+\/(\d+)/);
+  if (pathMatch) return pathMatch[1];
+  const queryMatch = input.match(/[?&]taskId=(\d+)/);
+  if (queryMatch) return queryMatch[1];
+  return input;
+}
+// ─── Main ────────────────────────────────────────────────────────────────────
+async function main() {
+  const { apiToken } = requireConfig();
+  const args = process.argv.slice(2);
+  const rawTaskId = args[0];
+  if (!rawTaskId || rawTaskId.startsWith('--')) {
+    console.error('Usage: node asana-update-notes.cjs <task-gid-or-url> --file <path> --section "<name>"');
+    console.error('Sections: "Implementation Detail", "QA Testing Instructions", or any custom name');
+    process.exit(1);
+  }
+  const taskGid = extractTaskGid(rawTaskId);
+  // Parse --section
+  const sectionIdx = args.indexOf('--section');
+  const sectionName = (sectionIdx !== -1 && args[sectionIdx + 1]) ? args[sectionIdx + 1] : null;
+  if (!sectionName) {
+    console.error('ERROR: --section is required. Example: --section "Implementation Detail"');
+    process.exit(1);
+  }
+  // Parse content from --file or stdin
+  let content = '';
+  const fileIdx = args.indexOf('--file');
+  if (fileIdx !== -1 && args[fileIdx + 1]) {
+    content = fs.readFileSync(args[fileIdx + 1], 'utf8').trim();
+  } else {
+    content = await readStdin();
+  }
+  if (!content) {
+    console.error('ERROR: No content provided (use --file <path> or pipe via stdin).');
+    process.exit(1);
+  }
+  // Fetch current task
+  console.log(`Fetching task ${taskGid}...`);
+  const result = await apiRequest(
+    'GET',
+    `/tasks/${encodeURIComponent(taskGid)}?opt_fields=gid,name,notes,html_notes`,
+    apiToken
+  );
+  const task = result.data || {};
+  const rawNotes = task.notes || '';
+  const htmlNotes = task.html_notes || '';
+  // Input is expected as HTML (from .html templates). Ensure <body> wrapper.
+  const contentHtml = content.includes('<body>') ? content : `<body>\n${content}\n</body>`;
+  const hasHtml = htmlNotes && htmlNotes.trim().length > 0 && htmlNotes !== '<body></body>';
+  const hasPlain = rawNotes && rawNotes.trim().length > 0;
+  // Case 1: Empty task — write fresh
+  if (!hasHtml && !hasPlain) {
+    console.log(`Task has no existing notes. Writing fresh ${sectionName}...`);
+    await apiRequest(
+      'PUT',
+      `/tasks/${encodeURIComponent(taskGid)}`,
+      apiToken,
+      { data: { notes: content, html_notes: minifyHtml(contentHtml) } }
+    );
+    console.log(`✓ Task ${taskGid} updated successfully (fresh notes).`);
+    return;
+  }
+  // Case 2: Has html_notes — use as base (preserves rich formatting)
+  if (hasHtml) {
+    let baseHtml = htmlNotes;
+    if ((!baseHtml || baseHtml === '<body></body>') && hasPlain) {
+      baseHtml = `<body>\n${rawNotes.replace(/\n/g, '<br>\n')}\n</body>`;
+    }
+    const existing = hasExistingSection(baseHtml, sectionName) || hasExistingSection(rawNotes, sectionName);
+    const newHtmlNotes = replaceOrAppendHtml(baseHtml, contentHtml, sectionName);
+    await apiRequest(
+      'PUT',
+      `/tasks/${encodeURIComponent(taskGid)}`,
+      apiToken,
+      { data: { html_notes: minifyHtml(newHtmlNotes) } }
+    );
+    console.log(existing ? `Replaced existing ${sectionName} section.` : `Appended ${sectionName} section.`);
+    console.log(`✓ Task ${taskGid} updated successfully.`);
+    return;
+  }
+  // Case 3: Plain notes only — convert everything to HTML
+  if (hasPlain) {
+    const existing = hasExistingSection(rawNotes, sectionName);
+    const updatedNotes = replaceOrAppendPlain(rawNotes, content, sectionName);
+    const newHtmlNotes = plainTextToHtml(updatedNotes);
+    await apiRequest(
+      'PUT',
+      `/tasks/${encodeURIComponent(taskGid)}`,
+      apiToken,
+      { data: { notes: updatedNotes, html_notes: minifyHtml(newHtmlNotes) } }
+    );
+    console.log(existing ? `Replaced existing ${sectionName} section.` : `Appended ${sectionName} section.`);
+    console.log(`✓ Task ${taskGid} updated successfully.`);
+    return;
+  }
+  exitManualMode(taskGid, content, 'Could not determine update mode. Please paste content manually.');
+}
+main().catch(err => { console.error('ERROR:', err.message); process.exit(1); });

package/agentic/antigravity/.agents/skills/asana-task/templates/id-tc.html ADDED Viewed

@@ -0,0 +1,20 @@
+<body>
+    <hr />
+    <h2><strong>Implementation Detail:</strong></h2>
+    <ul>
+        <li>{what_changed_1}</li>
+        <li>{what_changed_2}</li>
+        <li>{what_changed_3}</li>
+    </ul>
+    <h2><strong>Testing Checklist:</strong></h2>
+    <ul>
+        <li>[ ] {test_case_1}</li>
+        <li>[ ] {test_case_2}</li>
+        <li>[ ] {test_case_3}</li>
+    </ul>
+    <h2><strong>Files:</strong></h2>
+    <ul>
+        <li><code>{path/to/file_1.ext}</code></li>
+    </ul>
+</body>

package/agentic/antigravity/.agents/skills/asana-task/templates/qa-testing-instructions.html ADDED Viewed

@@ -0,0 +1,40 @@
+<body>
+<h1>QA Testing Instructions - {Jira-or-Task-ID}: {Short Title}</h1>
+<a href="{jira-url-if-available}">{jira-key}</a>
+<a href="{pr-url-if-available}">{pr-title}</a>
+<h2><strong>What Changed</strong></h2>
+<ul>
+<li>{user-visible change 1}</li>
+<li>{user-visible change 2}</li>
+<li>{user-visible change 3}</li>
+</ul>
+<h2><strong>Test Environment</strong></h2>
+<ul>
+<li>Platform: {iOS / Android / Web / All}</li>
+<li>Environment: {Dev / Staging / Production}</li>
+<li>Prerequisite: {role/account/data needed, or "None"}</li>
+</ul>
+<h2><strong>Test Cases</strong></h2>
+<hr/>
+<strong>TC-1: {short descriptive title}</strong>
+Steps:
+<ul>
+<li>{Detailed action step 1}</li>
+<li>{Detailed action step 2}</li>
+</ul>
+Expected:
+<ul>
+<li>{Precise expected result 1}</li>
+<li>{Precise expected result 2}</li>
+</ul>
+<hr/>
+<strong>TC-N [REGRESSION]: Other existing features unaffected</strong>
+Steps:
+<ul>
+<li>{Navigate to related screens or trigger related flows}</li>
+</ul>
+Expected:
+<ul>
+<li>No regressions in {related areas}</li>
+</ul>
+</body>

package/agentic/antigravity/.agents/skills/ask/SKILL.md ADDED Viewed

@@ -0,0 +1,66 @@
+---
+name: lu:ask
+description: "Answer technical and architectural questions with expert consultation."
+argument-hint: "[technical-question]"
+---
+# Technical Consultation
+Technical question or architecture challenge:
+<questions>$ARGUMENTS</questions>
+Current development workflows, system constraints, scale requirements, and business context will be considered:
+- Primary workflow: `./.claude/rules/primary-workflow.md`
+- Development rules: `./.claude/rules/development-rules.md`
+- Orchestration protocols: `./.claude/rules/orchestration-protocol.md`
+- Documentation management: `./.claude/rules/documentation-management.md`
+**Project Documentation:**
+```
+./docs
+├── project-overview-pdr.md
+├── code-standards.md
+├── codebase-summary.md
+├── design-guidelines.md
+├── deployment-guide.md
+├── system-architecture.md
+└── project-roadmap.md
+```
+## Your Role
+You are a Senior Systems Architect providing expert consultation and architectural guidance. You focus on high-level design, strategic decisions, and architectural patterns rather than implementation details. You orchestrate four specialized architectural advisors:
+1. **Systems Designer** – evaluates system boundaries, interfaces, and component interactions.
+2. **Technology Strategist** – recommends technology stacks, frameworks, and architectural patterns.
+3. **Scalability Consultant** – assesses performance, reliability, and growth considerations.
+4. **Risk Analyst** – identifies potential issues, trade-offs, and mitigation strategies.
+   You operate by the holy trinity of software engineering: **YAGNI** (You Aren't Gonna Need It), **KISS** (Keep It Simple, Stupid), and **DRY** (Don't Repeat Yourself). Every solution you propose must honor these principles.
+## Process
+1. **Problem Understanding**: Analyze the technical question and gather architectural context.
+   - If the architecture context doesn't contain the necessary information, use the `ck:scout` skill to scout the codebase again.
+2. **Expert Consultation**:
+   - Systems Designer: Define system boundaries, data flows, and component relationships
+   - Technology Strategist: Evaluate technology choices, patterns, and industry best practices
+   - Scalability Consultant: Assess non-functional requirements and scalability implications
+   - Risk Analyst: Identify architectural risks, dependencies, and decision trade-offs
+3. **Architecture Synthesis**: Combine insights to provide comprehensive architectural guidance.
+4. **Strategic Validation**: Ensure recommendations align with business goals and technical constraints.
+## Output Format
+**Be honest, be brutal, straight to the point, and be concise.**
+1. **Architecture Analysis** – comprehensive breakdown of the technical challenge and context.
+2. **Design Recommendations** – high-level architectural solutions with rationale and alternatives.
+3. **Technology Guidance** – strategic technology choices with pros/cons analysis.
+4. **Implementation Strategy** – phased approach and architectural decision framework.
+5. **Next Actions** – strategic next steps, proof-of-concepts, and architectural validation points.
+## Important
+This command focuses on architectural consultation and strategic guidance. Do not start implementing anything.

package/agentic/antigravity/.agents/skills/backend-development/SKILL.md ADDED Viewed

@@ -0,0 +1,96 @@
+---
+name: lu:backend-development
+description: Build backends with Node.js, Python, Go (NestJS, FastAPI, Django). Use for REST/GraphQL/gRPC APIs, auth (OAuth, JWT), databases, microservices, security (OWASP), Docker/K8s.
+license: MIT
+version: 1.0.0
+argument-hint: "[framework] [task]"
+---
+# Backend Development Skill
+Production-ready backend development with modern technologies, best practices, and proven patterns.
+## When to Use
+- Designing RESTful, GraphQL, or gRPC APIs
+- Building authentication/authorization systems
+- Optimizing database queries and schemas
+- Implementing caching and performance optimization
+- OWASP Top 10 security mitigation
+- Designing scalable microservices
+- Testing strategies (unit, integration, E2E)
+- CI/CD pipelines and deployment
+- Monitoring and debugging production systems
+## Technology Selection Guide
+**Languages:** Node.js/TypeScript (full-stack), Python (data/ML), Go (concurrency), Rust (performance)
+**Frameworks:** NestJS, FastAPI, Django, Express, Gin
+**Databases:** PostgreSQL (ACID), MongoDB (flexible schema), Redis (caching)
+**APIs:** REST (simple), GraphQL (flexible), gRPC (performance)
+See: `references/backend-technologies.md` for detailed comparisons
+## Reference Navigation
+**Core Technologies:**
+- `backend-technologies.md` - Languages, frameworks, databases, message queues, ORMs
+- `backend-api-design.md` - REST, GraphQL, gRPC patterns and best practices
+**Security & Authentication:**
+- `backend-security.md` - OWASP Top 10 2025, security best practices, input validation
+- `backend-authentication.md` - OAuth 2.1, JWT, RBAC, MFA, session management
+**Performance & Architecture:**
+- `backend-performance.md` - Caching, query optimization, load balancing, scaling
+- `backend-architecture.md` - Microservices, event-driven, CQRS, saga patterns
+**Quality & Operations:**
+- `backend-testing.md` - Testing strategies, frameworks, tools, CI/CD testing
+- `backend-code-quality.md` - SOLID principles, design patterns, clean code
+- `backend-devops.md` - Docker, Kubernetes, deployment strategies, monitoring
+- `backend-debugging.md` - Debugging strategies, profiling, logging, production debugging
+- `backend-mindset.md` - Problem-solving, architectural thinking, collaboration
+## Key Best Practices (2025)
+**Security:** Argon2id passwords, parameterized queries (98% SQL injection reduction), OAuth 2.1 + PKCE, rate limiting, security headers
+**Performance:** Redis caching (90% DB load reduction), database indexing (30% I/O reduction), CDN (50%+ latency cut), connection pooling
+**Testing:** 70-20-10 pyramid (unit-integration-E2E), Vitest 50% faster than Jest, contract testing for microservices, 83% migrations fail without tests
+**DevOps:** Blue-green/canary deployments, feature flags (90% fewer failures), Kubernetes 84% adoption, Prometheus/Grafana monitoring, OpenTelemetry tracing
+## Quick Decision Matrix
+| Need | Choose |
+|------|--------|
+| Fast development | Node.js + NestJS |
+| Data/ML integration | Python + FastAPI |
+| High concurrency | Go + Gin |
+| Max performance | Rust + Axum |
+| ACID transactions | PostgreSQL |
+| Flexible schema | MongoDB |
+| Caching | Redis |
+| Internal services | gRPC |
+| Public APIs | GraphQL/REST |
+| Real-time events | Kafka |
+## Implementation Checklist
+**API:** Choose style → Design schema → Validate input → Add auth → Rate limiting → Documentation → Error handling
+**Database:** Choose DB → Design schema → Create indexes → Connection pooling → Migration strategy → Backup/restore → Test performance
+**Security:** OWASP Top 10 → Parameterized queries → OAuth 2.1 + JWT → Security headers → Rate limiting → Input validation → Argon2id passwords
+**Testing:** Unit 70% → Integration 20% → E2E 10% → Load tests → Migration tests → Contract tests (microservices)
+**Deployment:** Docker → CI/CD → Blue-green/canary → Feature flags → Monitoring → Logging → Health checks
+## Resources
+- OWASP Top 10: https://owasp.org/www-project-top-ten/
+- OAuth 2.1: https://oauth.net/2.1/
+- OpenTelemetry: https://opentelemetry.io/