deveco-harness 0.1.0

package/skills/arkts-runtime-fix/scripts/shared/jscrash-parse.ts

@@ -0,0 +1,409 @@
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export type CrashReport = {
+  status: 'detected' | 'no_crash_signature';
+  source: string;
+  device: string;
+  bundle: string;
+  process: string;
+  errorType: string;
+  errorMessage: string;
+  suspectedFile: string;
+  keywords: string[];
+  topStack: string[];
+  excerpt: string[];
+};
+
+type ScoredLine = {
+  line: string;
+  index: number;
+  score: number;
+};
+
+const ERROR_TYPE_RE =
+  /(TypeError|ReferenceError|RangeError|SyntaxError|BusinessError|ParameterError|ResourceError|SystemError|EvalError|URIError)/i;
+const CRASH_SIGNAL_RE = /(jscrash|uncaught|exception|fatal|abort|crash|error)/i;
+const STRONG_CRASH_SIGNAL_RE =
+  /(jscrash|uncaught|fatal|abort|crash|TypeError|ReferenceError|RangeError|SyntaxError|BusinessError|ParameterError|ResourceError|SystemError|EvalError|URIError)/i;
+const FILE_RE = /([A-Za-z0-9_./\\-]+\.(ets|ts|js)(?::\d+:\d+)?)/i;
+
+function trim(input: string) {
+  return input.trim();
+}
+
+function cleanLines(input: string) {
+  return input
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter((line) => line.trim().length > 0);
+}
+
+function unique(items: string[]) {
+  return [...new Set(items)];
+}
+
+function containsIgnoreCase(input: string, token: string) {
+  return input.toLowerCase().includes(token.toLowerCase());
+}
+
+function firstMatch(input: string, patterns: RegExp[]) {
+  for (const pattern of patterns) {
+    const match = pattern.exec(input);
+    if (match?.[1]) {
+      return match[1].trim();
+    }
+  }
+
+  return '';
+}
+
+function errorTypeFromText(input: string) {
+  const matches = input.match(new RegExp(ERROR_TYPE_RE.source, 'ig'));
+  if (!matches?.length) {
+    return '';
+  }
+
+  return matches[matches.length - 1];
+}
+
+function detectErrorType(lines: string[], anchor: number, focus: string) {
+  const headerText = lines.slice(0, 48).join('\n');
+  const fromHeader = errorTypeFromText(headerText);
+  if (fromHeader) {
+    return fromHeader;
+  }
+
+  for (const line of lines.slice(0, 48)) {
+    const match = /^(?:Reason|Error\s+name|Error\s+type)\s*[:：]\s*([A-Za-z]+Error)\s*$/i.exec(line.trim());
+    if (match?.[1] && ERROR_TYPE_RE.test(match[1])) {
+      return match[1];
+    }
+  }
+
+  if (anchor >= 0) {
+    const aroundAnchor = errorTypeFromText(sliceWindow(lines, anchor, 12, 8).join('\n'));
+    if (aroundAnchor) {
+      return aroundAnchor;
+    }
+  }
+
+  const fromFocus = errorTypeFromText(focus);
+  if (fromFocus) {
+    return fromFocus;
+  }
+
+  return 'UnknownError';
+}
+
+function detectBundle(input: string, bundleName: string) {
+  if (bundleName) {
+    return bundleName;
+  }
+
+  return (
+    firstMatch(input, [
+      /bundleName\s*[:=]\s*([A-Za-z0-9._-]+)/i,
+      /bundle\s*[:=]\s*([A-Za-z0-9._-]+)/i,
+      /app\s*[:=]\s*([A-Za-z0-9._-]+)/i,
+    ]) || '(unknown)'
+  );
+}
+
+function detectProcess(input: string, processHint: string) {
+  if (processHint) {
+    return processHint;
+  }
+
+  return (
+    firstMatch(input, [
+      /(?:process(?:Name)?)\s*[:=]\s*([A-Za-z0-9._-]+)/i,
+      /pid\s*[:=]\s*([0-9]+)/i,
+    ]) || '(unknown)'
+  );
+}
+
+function stackLike(line: string) {
+  return (
+    /at\s+.+:\d+:\d+/i.test(line) ||
+    /at\s+.+\(.+:\d+:\d+\)/i.test(line) ||
+    /([A-Za-z0-9_./\\-]+\.(ets|ts|js)):\d+:\d+/.test(line)
+  );
+}
+
+function applicationFrameScore(line: string, bundle: string) {
+  let score = 0;
+  if (/entry[\\/].*\.ets/i.test(line)) {
+    score += 8;
+  }
+  if (/src[\\/].*\.(ets|ts|js)/i.test(line)) {
+    score += 6;
+  }
+  if (bundle !== '(unknown)' && containsIgnoreCase(line, bundle)) {
+    score += 4;
+  }
+  if (/(pages|page|feature|component|viewmodel|store|model)[\\/]/i.test(line)) {
+    score += 3;
+  }
+  if (/(framework|runtime|node_modules|oh_modules|libarkui|ets_runtime|foundation|system)[\\/]/i.test(line)) {
+    score -= 6;
+  }
+
+  return score;
+}
+
+function scoreCrashLine(line: string, bundle: string, processHint: string) {
+  let score = 0;
+  if (CRASH_SIGNAL_RE.test(line)) {
+    score += 5;
+  }
+  if (STRONG_CRASH_SIGNAL_RE.test(line)) {
+    score += 4;
+  }
+  if (ERROR_TYPE_RE.test(line)) {
+    score += 4;
+  }
+  if (stackLike(line)) {
+    score += 2;
+  }
+  if (bundle && bundle !== '(unknown)' && containsIgnoreCase(line, bundle)) {
+    score += 2;
+  }
+  if (processHint && processHint !== '(unknown)' && containsIgnoreCase(line, processHint)) {
+    score += 2;
+  }
+
+  return score;
+}
+
+function findCrashAnchor(lines: string[], bundle: string, processHint: string) {
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const score = scoreCrashLine(lines[index], bundle, processHint);
+    if (score >= 7) {
+      return index;
+    }
+  }
+
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const score = scoreCrashLine(lines[index], bundle, processHint);
+    if (score >= 5) {
+      return index;
+    }
+  }
+
+  return -1;
+}
+
+function sliceWindow(lines: string[], anchor: number, before: number, after: number) {
+  if (anchor < 0) {
+    return [];
+  }
+
+  const start = Math.max(0, anchor - before);
+  const end = Math.min(lines.length, anchor + after + 1);
+
+  return lines.slice(start, end);
+}
+
+function findCrashSignal(lines: string[], start: number, end: number, step: 1 | -1) {
+  for (let index = start; step > 0 ? index < end : index >= end; index += step) {
+    if (CRASH_SIGNAL_RE.test(lines[index])) {
+      return lines[index].trim();
+    }
+  }
+
+  return '';
+}
+
+function detectErrorMessage(lines: string[], anchor: number) {
+  if (anchor >= 0) {
+    const forwardMatch = findCrashSignal(lines, anchor, Math.min(lines.length, anchor + 6), 1);
+    if (forwardMatch) {
+      return forwardMatch;
+    }
+
+    const backwardMatch = findCrashSignal(lines, anchor, Math.max(0, anchor - 3), -1);
+    if (backwardMatch) {
+      return backwardMatch;
+    }
+
+    return lines[anchor].trim();
+  }
+
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (CRASH_SIGNAL_RE.test(lines[index])) {
+      return lines[index].trim();
+    }
+  }
+
+  return lines[lines.length - 1] || '(not found)';
+}
+
+function detectTopStack(lines: string[], anchor: number) {
+  const around = anchor >= 0 ? sliceWindow(lines, anchor, 4, 18) : lines.slice(Math.max(0, lines.length - 24));
+  const frames = around.filter((line) => stackLike(line));
+
+  return unique(frames).slice(0, 8);
+}
+
+function detectSuspectedFile(topStack: string[], bundle: string) {
+  const candidates: ScoredLine[] = [];
+  for (let index = 0; index < topStack.length; index += 1) {
+    const line = topStack[index];
+    const match = FILE_RE.exec(line);
+    if (!match?.[1]) {
+      continue;
+    }
+
+    candidates.push({
+      line: match[1],
+      index,
+      score: applicationFrameScore(match[1], bundle) - index,
+    });
+  }
+
+  if (!candidates.length) {
+    return '(not found)';
+  }
+
+  candidates.sort((a, b) => b.score - a.score || a.index - b.index);
+
+  return candidates[0].line;
+}
+
+function detectKeywords(input: string) {
+  const candidates = [
+    'jscrash',
+    'uncaught',
+    'exception',
+    'fatal',
+    'typeerror',
+    'referenceerror',
+    'rangeerror',
+    'syntaxerror',
+    'businesserror',
+    'parametererror',
+    'resourceerror',
+    'systemerror',
+    'abort',
+    'crash',
+  ];
+
+  return candidates.filter((item) => containsIgnoreCase(input, item));
+}
+
+function looksLikeCrash(input: string, anchor: number, errorType: string) {
+  if (errorType !== 'UnknownError') {
+    return true;
+  }
+  if (anchor >= 0) {
+    return true;
+  }
+
+  return /(jscrash|uncaught|fatal|abort|crash)/i.test(input);
+}
+
+function pickExcerpt(lines: string[], anchor: number, bundle: string, processHint: string, limit: number) {
+  if (anchor >= 0) {
+    const around = sliceWindow(lines, anchor, 5, 18);
+    if (around.length) {
+      return around.slice(0, limit);
+    }
+  }
+
+  const scored = lines
+    .map((line, index) => ({
+      line,
+      index,
+      score: scoreCrashLine(line, bundle, processHint),
+    }))
+    .filter((item) => item.score > 0);
+
+  if (!scored.length) {
+    return lines.slice(Math.max(0, lines.length - limit));
+  }
+
+  const out: string[] = [];
+  for (const item of scored.slice(Math.max(0, scored.length - limit))) {
+    out.push(item.line);
+  }
+
+  return unique(out).slice(0, limit);
+}
+
+export function buildNextActionText(report: CrashReport) {
+  if (report.status === 'no_crash_signature') {
+    return 'Ask for a fuller crash log, a clearer repro, or optionally collect recent faultlogger or hilog evidence if needed.';
+  }
+  if (report.suspectedFile !== '(not found)') {
+    return `Inspect ${report.suspectedFile} first and make a minimal fix. Collect additional runtime evidence only if the current anchor is still too weak.`;
+  }
+
+  return 'Inspect the top stack frames first and make a minimal fix. If the stack is too weak, optionally collect more runtime evidence before broader code reading.';
+}
+
+export function formatCrashReportText(report: CrashReport) {
+  return [
+    report.status === 'detected' ? 'Crash signature detected.' : 'No clear crash signature detected.',
+    `source: ${report.source}`,
+    `device: ${report.device}`,
+    `bundle: ${report.bundle}`,
+    `process: ${report.process}`,
+    `error_type: ${report.errorType}`,
+    `error_message: ${report.errorMessage}`,
+    `suspected_file: ${report.suspectedFile}`,
+    `keywords: ${report.keywords.length ? report.keywords.join(', ') : '(none)'}`,
+    '',
+    'Top stack:',
+    ...(report.topStack.length ? report.topStack : ['(empty)']),
+    '',
+    'Evidence excerpt:',
+    ...(report.excerpt.length ? report.excerpt : ['(empty)']),
+    '',
+    `next_action: ${buildNextActionText(report)}`,
+  ].join('\n');
+}
+
+export function buildCrashReport(
+  input: string,
+  source: string,
+  device: string,
+  bundleName: string,
+  processHint: string,
+): CrashReport {
+  const normalized = trim(input);
+  const lines = cleanLines(normalized);
+  const bundle = detectBundle(normalized, bundleName);
+  const process = detectProcess(normalized, processHint);
+  const anchor = findCrashAnchor(lines, bundle, process);
+  const focus = anchor >= 0 ? sliceWindow(lines, anchor, 5, 18).join('\n') : normalized;
+  const errorType = detectErrorType(lines, anchor, focus);
+  const topStack = detectTopStack(lines, anchor);
+  const excerpt = pickExcerpt(lines, anchor, bundle, process, 24);
+
+  return {
+    status: looksLikeCrash(normalized, anchor, errorType) ? 'detected' : 'no_crash_signature',
+    source,
+    device,
+    bundle,
+    process,
+    errorType,
+    errorMessage: detectErrorMessage(lines, anchor),
+    suspectedFile: detectSuspectedFile(topStack, bundle),
+    keywords: detectKeywords(focus || normalized),
+    topStack,
+    excerpt,
+  };
+}

package/skills/arkts-runtime-fix/scripts/shared/utils.mjs

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function printKv(lines) {
+  const out = [];
+  for (const [key, value] of Object.entries(lines)) {
+    out.push(`${key}: ${value}`);
+  }
+
+  console.log(out.join('\n'));
+}

package/skills/arkts-runtime-fix/scripts/shared/utils.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2026 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export function toErrorMessage(error: unknown) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function printKv(lines: Record<string, string>) {
+  const out: string[] = [];
+  for (const [key, value] of Object.entries(lines)) {
+    out.push(`${key}: ${value}`);
+  }
+
+  console.log(out.join('\n'));
+}

package/skills/arkui-knowledge/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: arkui-knowledge
+description: Load this skill when answering ArkUI UI questions or when writing/modifying ArkUI components, layouts, state-driven UI, rendering control, navigation, dialogs, interactions, component APIs, or ArkUI declarative UI in .ets files.
+---
+
+# ArkUI Knowledge
+
+Use this skill for ArkUI UI knowledge and implementation guidance. It helps answer ArkUI questions and helps agents write correct, polished ArkUI code on the first pass.
+
+## When to load
+
+Load this skill when the task involves:
+
+- ArkUI components, component modifiers, component nesting, or declarative UI structure.
+- Layout with `Column`, `Row`, `Stack`, `Flex`, `Grid`, `List`, `Scroll`, `Tabs`, or `TabContent`.
+- UI state refresh with `@State`, `@Prop`, `@Link`, `@Local`, `@Param`, `@Provide`, `@Consume`, or related decorators.
+- Rendering control with `ForEach`, `LazyForEach`, conditional UI, builders, or reusable UI blocks.
+- Navigation, dialogs, toast prompts, menus, gestures, animation, visual styling, or UI quality.
+- Writing or modifying `.ets` files that render visible ArkUI surfaces.
+
+Do not load this skill for:
+
+- Plain ArkTS syntax restrictions with no UI component concern; use `arkts-grammar-standards`.
+- Build or type errors after compilation fails; use `arkts-error-fixes`.
+- Runtime crashes, white screens, jscrash logs, or uncaught exceptions; use `arkts-runtime-fix`.
+- New project creation or empty project initialization; use `deveco-create-project`.
+
+## Responsibilities
+
+- Explain ArkUI concepts, APIs, component choices, and correct usage.
+- Guide page and component structure while preserving the current project style.
+- Prevent high-frequency ArkUI mistakes before code is written.
+- Improve UI quality: visible required text, clickable required controls, stable layout, state refresh, and minimal unrelated edits.
+- Keep ArkUI guidance separate from ArkTS language restrictions and post-build error repair.
+
+## Before answering or coding
+
+1. Identify the ArkUI topic: component, layout, state, rendering, navigation, dialog, interaction, animation, or visual quality.
+2. For questions, answer directly, then add the correct usage, common trap, and applicable boundary.
+3. For code changes, read the target `.ets` file first. Keep the existing state-management style, navigation style, directory style, and business flow.
+4. Check the relevant reference before using a high-risk API:
+   - `references/component-cookbook.md`
+   - `references/api-guardrails.md`
+   - `references/common-mistakes.md`
+   - `references/ui-quality-checklist.md`
+5. If a component signature, enum, callback parameter, or modifier owner is unclear and the local references do not cover it, inspect official/project documentation or existing project usage before writing code.
+
+## ArkUI component guardrails
+
+- `Tabs` can contain `TabContent` directly. Build tabs with `Tabs(...) { TabContent() { ... }.tabBar(...) }`.
+- Do not pass a `builder` object into `TabContent`; use `TabContent()` and set the label with `.tabBar(...)`.
+- `ForEach` and `LazyForEach` key generators should return a stable string key from the item. Avoid `void` keys and index keys for business data.
+- Place ArkUI state decorators only on component member declarations with the correct V1 or V2 decorator family. Do not mix V1 and V2 decorators in one component.
+- Do not invent modifier names. Use full ArkUI names including `.backgroundColor()`, `.borderRadius()`, `.fontSize()`, and `.fontColor()`.
+- Match modifiers to component owners. For example, text modifiers belong on `Text`, image fitting belongs on `Image`, and layout alignment differs by container.
+- Prefer the existing navigation approach in the project. Do not replace router, `Navigation`, or custom app routers without a clear requirement.
+- For dialogs, toast prompts, navigation, and animation, prefer valid UI context usage when the current project already follows that pattern.
+
+## Common mistakes
+
+Read `references/common-mistakes.md` before implementing UI with tabs, lists, decorators, dialogs, navigation, or custom builders.
+
+High-risk mistakes to avoid:
+
+- `TabContent` with a fake object parameter.
+- `Tabs` containing direct non-`TabContent` children.
+- `ForEach` key generator with a block body that does not return a string.
+- `@State` on top-level variables, local variables, plain classes, or component inputs.
+- `@ComponentV2` using V1 decorators including `@State`.
+- Component modifiers borrowed from web, Android, other UI frameworks, or CSS shorthand.
+- Dialog button fields with the wrong key names.
+- Required UI text hidden by layout, overlay, tiny size, or unreachable navigation.
+
+## UI quality checklist
+
+Use `references/ui-quality-checklist.md` before finalizing UI work. At minimum:
+
+- Required labels, buttons, cards, tabs, and dialog text are visible on the target screen.
+- Required clicks update state, open the dialog, switch the tab, navigate, or show the expected response.
+- New UI fits the current page density, spacing, color, and component style.
+- Layout has stable dimensions where dynamic content could otherwise shift or overlap.
+- The change is limited to files needed by the UI request.
+
+## Boundaries with other skills
+
+- Use `arkts-grammar-standards` for ArkTS language rules, TypeScript-to-ArkTS differences, template literals, dynamic property access, object literal typing, and syntax compliance.
+- Use `arkts-error-fixes` only after compilation reports errors or when directly fixing build/type failures.
+- Use `arkts-runtime-fix` for runtime stack traces, white screens, uncaught exceptions, and jscrash logs.
+- Use `deveco-create-project` for project initialization.
+- Do not perform state-management migration unless the user explicitly asks for that migration.

package/skills/arkui-knowledge/references/api-guardrails.md

@@ -0,0 +1,60 @@
+# ArkUI API Guardrails
+
+Use these rules before writing ArkUI component constructors, modifiers, enum values, or callbacks.
+
+## Component constructors
+
+- `Tabs(options?)` accepts options including `barPosition`, `index`, and `controller`.
+- `TabContent()` takes no object parameter; set the label with `.tabBar(...)`.
+- `List({ space })` and `Grid()` contain their required item child components.
+- `Row({ space })` and `Column({ space })` take spacing in the constructor.
+- `Flex()` does not take a `space` option; use margins on children when needed.
+- `Stack({ alignContent })` controls stack alignment; do not use row/column alignment methods on it.
+
+## Modifier names
+
+Use full ArkUI modifier names:
+
+- `.backgroundColor(...)`
+- `.borderRadius(...)`
+- `.fontSize(...)`
+- `.fontColor(...)`
+- `.fontWeight(...)`
+- `.textAlign(...)`
+- `.objectFit(...)`
+- `.textOverflow(...)`
+
+Do not use shorthand names from other UI systems, including shortened background, radius, text size, or text color modifiers. Do not use Android layout constants for width or height.
+
+## Modifier ownership
+
+- `Text` owns text modifiers including `.fontSize(...)`, `.fontColor(...)`, `.fontWeight(...)`, `.textAlign(...)`, `.maxLines(...)`, and `.textOverflow(...)`.
+- `Image` owns image modifiers including `.objectFit(...)`.
+- `Column` and `Row` own layout alignment, but their alignment enum types differ.
+- `Button` label styling is often clearer by placing styled `Text` inside `Button` when project style requires custom text styling.
+- `List` owns list-level direction, edge, divider, and scroll behavior; `ListItem` owns per-row content.
+
+## Parameters and callbacks
+
+- `margin` and `padding` use a number, string, or object with edge names. Do not use multi-argument CSS-style shorthand.
+- `AlertDialog` button entries use `{ value: '确定', action: () => {} }`.
+- `ActionSheet` entries use `sheets`.
+- Popup state-change callbacks receive an event object with visibility state.
+- Event callback parameter types should be explicit when inference is unclear.
+
+## Enums and resources
+
+- Use ArkUI enum names with exact casing, for example `TextAlign.Center`, `FontWeight.Bold`, and `BarPosition.End`.
+- Do not pass string values where an enum is expected.
+- Do not guess system symbol or system color names. Use existing project resources or verified names.
+
+## UIContext-sensitive APIs
+
+When a project already uses UIContext for UI operations, follow it for:
+
+- Toast prompts through `this.getUIContext().getPromptAction()`.
+- Alert dialogs through `this.getUIContext().showAlertDialog(...)`.
+- Router access through `this.getUIContext().getRouter()`.
+- Animation through `this.getUIContext().animateTo(...)`.
+
+If the current project has a wrapper for routing, dialog, toast, or logging, use the wrapper instead of introducing a new pattern.